home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / TreeMod1.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  96KB  |  2,967 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_General
  16. #include "General.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Texts
  28. #include "Texts.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Sets
  32. #include "Sets.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeMod2
  36. #include "TreeMod2.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree
  40. #include "Tree.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Strings
  44. #include "Strings.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_TreeMod1
  48. #include "TreeMod1.h"
  49. #endif
  50.  
  51. IO_tFile TreeMod1_yyf;
  52. PROC TreeMod1_Exit;
  53.  
  54. static INTEGER ConstCount, ListCount;
  55. static Idents_tIdent iRange, iClassName;
  56. static Tree_tTree Node;
  57. static SHORTCARD gBitCount;
  58. static SHORTCARD i, MaxBit;
  59. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  60. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  61. struct S_3 {
  62.     union {
  63.         char dummy;
  64.     } U_1;
  65. };
  66. static void ConstDecls ARGS((Tree_tTree t));
  67. struct S_4 {
  68.     union {
  69.         char dummy;
  70.     } U_1;
  71. };
  72. static void TypeDeclNode ARGS((Tree_tTree t));
  73. struct S_5 {
  74.     union {
  75.         char dummy;
  76.     } U_1;
  77. };
  78. static void TypeDeclRecord ARGS((Tree_tTree t));
  79. struct S_6 {
  80.     union {
  81.         char dummy;
  82.     } U_1;
  83. };
  84. static void ProcedureDeclsn ARGS((Tree_tTree t));
  85. struct S_7 {
  86.     union {
  87.         char dummy;
  88.     } U_1;
  89. };
  90. static void ProcedureHeadingm ARGS((Tree_tTree t));
  91. struct S_8 {
  92.     union {
  93.         char dummy;
  94.     } U_1;
  95. };
  96. struct S_9 {
  97.     union {
  98.         char dummy;
  99.     } U_1;
  100. };
  101. static void ProcedureBodyn ARGS((Tree_tTree t));
  102. struct S_10 {
  103.     union {
  104.         char dummy;
  105.     } U_1;
  106. };
  107. static void ProcedureBodym ARGS((Tree_tTree t));
  108. struct S_11 {
  109.     union {
  110.         char dummy;
  111.     } U_1;
  112. };
  113. static void ReleaseAttributes1 ARGS((Tree_tTree t));
  114. struct S_12 {
  115.     union {
  116.         char dummy;
  117.     } U_1;
  118. };
  119. static void ReleaseAttributes2 ARGS((Tree_tTree t));
  120. struct S_13 {
  121.     union {
  122.         char dummy;
  123.     } U_1;
  124. };
  125. static void TraverseTD ARGS((Tree_tTree t));
  126. struct S_14 {
  127.     union {
  128.         char dummy;
  129.     } U_1;
  130. };
  131. static void TraverseBU ARGS((Tree_tTree t));
  132. struct S_15 {
  133.     union {
  134.         char dummy;
  135.     } U_1;
  136. };
  137. static void Reverse1 ARGS((Tree_tTree t));
  138. struct S_16 {
  139.     union {
  140.         char dummy;
  141.     } U_1;
  142. };
  143. static void Reverse2 ARGS((Tree_tTree t));
  144. struct S_17 {
  145.     union {
  146.         char dummy;
  147.     } U_1;
  148. };
  149. static void Copy ARGS((Tree_tTree t));
  150. struct S_18 {
  151.     union {
  152.         char dummy;
  153.     } U_1;
  154. };
  155. static void CheckAttributes ARGS((Tree_tTree t));
  156. struct S_19 {
  157.     union {
  158.         char dummy;
  159.     } U_1;
  160. };
  161. static void InitTypeRange ARGS((Tree_tTree t));
  162. struct S_20 {
  163.     union {
  164.         char dummy;
  165.     } U_1;
  166. };
  167. static void InitTypeRange2 ARGS((Tree_tTree t));
  168. struct S_21 {
  169.     union {
  170.         char dummy;
  171.     } U_1;
  172. };
  173. static void QueryAttributes ARGS((Tree_tTree t));
  174. struct S_22 {
  175.     union {
  176.         char dummy;
  177.     } U_1;
  178. };
  179. static void IsEqualAttributes ARGS((Tree_tTree t));
  180. struct S_23 {
  181.     union {
  182.         char dummy;
  183.     } U_1;
  184. };
  185. static void InitAttributes ARGS((Tree_tTree t));
  186. struct S_24 {
  187.     union {
  188.         char dummy;
  189.     } U_1;
  190. };
  191. static void InitNodeSize ARGS((Tree_tTree t));
  192. struct S_25 {
  193.     union {
  194.         char dummy;
  195.     } U_1;
  196. };
  197. struct S_26 {
  198.     union {
  199.         char dummy;
  200.     } U_1;
  201. };
  202. static void ImportConst ARGS((Tree_tTree t));
  203. struct S_27 {
  204.     union {
  205.         char dummy;
  206.     } U_1;
  207. };
  208. static void CompMaxBit ARGS((Tree_tTree t));
  209. struct S_28 {
  210.     union {
  211.         char dummy;
  212.     } U_1;
  213. };
  214. static void yyExit ARGS(());
  215.  
  216.  
  217. static void yyAbort
  218. # ifdef __STDC__
  219. (CHAR yyFunction[], LONGCARD O_1)
  220. # else
  221. (yyFunction, O_1)
  222. CHAR yyFunction[];
  223. LONGCARD O_1;
  224. # endif
  225. {
  226.   OPEN_ARRAY_LOCALS
  227.  
  228.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  229.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  230.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module TreeMod1, routine ", 32L);
  231.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  232.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  233.   IO_WriteNl((System_tFile)IO_StdError);
  234.   (*TreeMod1_Exit)();
  235.   FREE_OPEN_ARRAYS
  236. }
  237.  
  238. static BOOLEAN yyIsEqual
  239. # ifdef __STDC__
  240. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  241. # else
  242. (yya, O_3, yyb, O_2)
  243. BYTE yya[];
  244. LONGCARD O_3;
  245. BYTE yyb[];
  246. LONGCARD O_2;
  247. # endif
  248. {
  249.   INTEGER yyi;
  250.   OPEN_ARRAY_LOCALS
  251.  
  252.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  253.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  254.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  255.   {
  256.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  257.  
  258.     if (B_1 <= B_2)
  259.       for (yyi = B_1;; yyi += 1) {
  260.         if (yya[yyi] != yyb[yyi]) {
  261.           FREE_OPEN_ARRAYS
  262.           return FALSE;
  263.         }
  264.         if (yyi >= B_2) break;
  265.       }
  266.   }
  267.   FREE_OPEN_ARRAYS
  268.   return TRUE;
  269. }
  270.  
  271. void TreeMod1_TreeDefMod
  272. # ifdef __STDC__
  273. (Tree_tTree t)
  274. # else
  275. (t)
  276. Tree_tTree t;
  277. # endif
  278. {
  279.   struct S_3 yyTempo;
  280.  
  281.   if (t == Tree_NoTree) {
  282.     return;
  283.   }
  284.   if (t->U_1.V_1.Kind == Tree_Ag) {
  285.     {
  286.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  287.  
  288.       IO_WriteS(Tree_f, (STRING)"DEFINITION MODULE ", 18L);
  289.       Tree_WI(Tree_iModule);
  290.       IO_WriteS(Tree_f, (STRING)";", 1L);
  291.       IO_WriteNl(Tree_f);
  292.       IO_WriteNl(Tree_f);
  293.       if (Sets_IsElement(ORD('<'), &Tree_Options)) {
  294.         IO_WriteS(Tree_f, (STRING)"FROM ", 5L);
  295.         Tree_WI(Tree_iMain);
  296.         IO_WriteS(Tree_f, (STRING)" IMPORT ", 8L);
  297.         Tree_WI(Tree_itTree);
  298.         IO_WriteS(Tree_f, (STRING)", tProcTree;", 12L);
  299.         IO_WriteNl(Tree_f);
  300.       }
  301.       IO_WriteS(Tree_f, (STRING)"IMPORT SYSTEM, IO;", 18L);
  302.       IO_WriteNl(Tree_f);
  303.       TreeMod2_WriteLine(W_1->TreeCodes->U_1.V_12.Codes.ImportLine);
  304.       Texts_WriteText(Tree_f, W_1->TreeCodes->U_1.V_12.Codes.Import);
  305.       Node = W_1->Modules;
  306.       while (Node->U_1.V_1.Kind == Tree_Module) {
  307.         TreeMod2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.ImportLine);
  308.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Import);
  309.         Node = Node->U_1.V_43.Module.Next;
  310.       }
  311.       IO_WriteNl(Tree_f);
  312.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  313.         IO_WriteS(Tree_f, (STRING)"CONST", 5L);
  314.         IO_WriteNl(Tree_f);
  315.         Tree_WI(Tree_iNoTree);
  316.         IO_WriteS(Tree_f, (STRING)" = NIL;", 7L);
  317.         IO_WriteNl(Tree_f);
  318.         IO_WriteNl(Tree_f);
  319.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ConstDecls);
  320.         IO_WriteNl(Tree_f);
  321.         IO_WriteS(Tree_f, (STRING)"TYPE ", 5L);
  322.         Tree_WI(Tree_itTree);
  323.         IO_WriteS(Tree_f, (STRING)" = POINTER TO yyNode;", 21L);
  324.         IO_WriteNl(Tree_f);
  325.         IO_WriteS(Tree_f, (STRING)"tProcTree = PROCEDURE (", 23L);
  326.         Tree_WI(Tree_itTree);
  327.         IO_WriteS(Tree_f, (STRING)");", 2L);
  328.         IO_WriteNl(Tree_f);
  329.       }
  330.       TreeMod2_WriteLine(W_1->TreeCodes->U_1.V_12.Codes.ExportLine);
  331.       Texts_WriteText(Tree_f, W_1->TreeCodes->U_1.V_12.Codes.Export);
  332.       Node = W_1->Modules;
  333.       while (Node->U_1.V_1.Kind == Tree_Module) {
  334.         TreeMod2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.ExportLine);
  335.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Export);
  336.         Node = Node->U_1.V_43.Module.Next;
  337.       }
  338.       IO_WriteNl(Tree_f);
  339.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  340.         IO_WriteS(Tree_f, (STRING)"# ifndef yyNodeHead", 19L);
  341.         IO_WriteNl(Tree_f);
  342.         IO_WriteS(Tree_f, (STRING)"# define yyNodeHead", 19L);
  343.         IO_WriteNl(Tree_f);
  344.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  345.         IO_WriteNl(Tree_f);
  346.         IO_WriteS(Tree_f, (STRING)"TYPE", 4L);
  347.         IO_WriteNl(Tree_f);
  348.         if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  349.           MaxBit = 0;
  350.           Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)CompMaxBit);
  351.           IO_WriteS(Tree_f, (STRING)"yytNodeHead = RECORD yyKind, yyMark, yyOffset: SHORTCARD; yyParent: ", 68L);
  352.           Tree_WI(Tree_itTree);
  353.           IO_WriteS(Tree_f, (STRING)"; yyIsComp0", 11L);
  354.           if (Sets_IsElement(ORD('5'), &Tree_Options)) {
  355.             IO_WriteS(Tree_f, (STRING)", yyIsDone0", 11L);
  356.           }
  357.           {
  358.             SHORTCARD B_3 = 1, B_4 = (MaxBit - 1) / TreeMod1_BSS;
  359.  
  360.             if (B_3 <= B_4)
  361.               for (i = B_3;; i += 1) {
  362.                 IO_WriteS(Tree_f, (STRING)", yyIsComp", 10L);
  363.                 Tree_WN((LONGINT)i);
  364.                 if (Sets_IsElement(ORD('5'), &Tree_Options)) {
  365.                   IO_WriteS(Tree_f, (STRING)", yyIsDone", 10L);
  366.                   Tree_WN((LONGINT)i);
  367.                 }
  368.                 if (i >= B_4) break;
  369.               }
  370.           }
  371.           IO_WriteS(Tree_f, (STRING)": BITSET; yyNodeHead END;", 25L);
  372.           IO_WriteNl(Tree_f);
  373.         } else {
  374.           IO_WriteS(Tree_f, (STRING)"yytNodeHead = RECORD yyKind, yyMark: SHORTCARD; yyNodeHead END;", 63L);
  375.           IO_WriteNl(Tree_f);
  376.         }
  377.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)TypeDeclNode);
  378.         IO_WriteNl(Tree_f);
  379.         IO_WriteS(Tree_f, (STRING)"yyNode = RECORD", 15L);
  380.         IO_WriteNl(Tree_f);
  381.         IO_WriteS(Tree_f, (STRING)"CASE : SHORTCARD OF", 19L);
  382.         IO_WriteNl(Tree_f);
  383.         IO_WriteS(Tree_f, (STRING)"| 0: Kind: SHORTCARD;", 21L);
  384.         IO_WriteNl(Tree_f);
  385.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  386.         Tree_WN(Tree_ClassCount + 1);
  387.         IO_WriteS(Tree_f, (STRING)": yyHead: yytNodeHead;", 22L);
  388.         IO_WriteNl(Tree_f);
  389.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)TypeDeclRecord);
  390.         IO_WriteS(Tree_f, (STRING)"END;", 4L);
  391.         IO_WriteNl(Tree_f);
  392.         IO_WriteS(Tree_f, (STRING)"END;", 4L);
  393.         IO_WriteNl(Tree_f);
  394.         IO_WriteNl(Tree_f);
  395.         IO_WriteS(Tree_f, (STRING)"VAR ", 4L);
  396.         Tree_WI(Tree_iMain);
  397.         IO_WriteS(Tree_f, (STRING)"Root    : ", 7L);
  398.         Tree_WI(Tree_itTree);
  399.         IO_WriteS(Tree_f, (STRING)";", 1L);
  400.         IO_WriteNl(Tree_f);
  401.         IO_WriteS(Tree_f, (STRING)"VAR HeapUsed    : LONGCARD;", 24L);
  402.         IO_WriteNl(Tree_f);
  403.         IO_WriteS(Tree_f, (STRING)"VAR yyPoolFreePtr, yyPoolMaxPtr    : SYSTEM.ADDRESS;", 49L);
  404.         IO_WriteNl(Tree_f);
  405.         IO_WriteS(Tree_f, (STRING)"VAR yyNodeSize    : ARRAY [0..", 27L);
  406.         Tree_WN(Tree_ClassCount);
  407.         IO_WriteS(Tree_f, (STRING)"] OF SHORTCARD;", 15L);
  408.         IO_WriteNl(Tree_f);
  409.         IO_WriteS(Tree_f, (STRING)"VAR yyExit    : PROC;", 18L);
  410.         IO_WriteNl(Tree_f);
  411.         IO_WriteNl(Tree_f);
  412.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyAlloc    (): ", 22L);
  413.         Tree_WI(Tree_itTree);
  414.         IO_WriteS(Tree_f, (STRING)";", 1L);
  415.         IO_WriteNl(Tree_f);
  416.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Make", 14L);
  417.         Tree_WI(Tree_iMain);
  418.         IO_WriteS(Tree_f, (STRING)"    (Kind: SHORTCARD): ", 20L);
  419.         Tree_WI(Tree_itTree);
  420.         IO_WriteS(Tree_f, (STRING)";", 1L);
  421.         IO_WriteNl(Tree_f);
  422.         IO_WriteS(Tree_f, (STRING)"PROCEDURE IsType    (Tree: ", 24L);
  423.         Tree_WI(Tree_itTree);
  424.         IO_WriteS(Tree_f, (STRING)"; Kind: SHORTCARD): BOOLEAN;", 28L);
  425.         IO_WriteNl(Tree_f);
  426.         IO_WriteNl(Tree_f);
  427.       }
  428.       if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  429.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ProcedureDeclsn);
  430.         IO_WriteNl(Tree_f);
  431.       }
  432.       if (Sets_IsElement(ORD('m'), &Tree_Options)) {
  433.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ProcedureHeadingm);
  434.         IO_WriteNl(Tree_f);
  435.       }
  436.       if (Sets_IsElement(ORD('f'), &Tree_Options)) {
  437.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Release", 17L);
  438.         Tree_WI(Tree_iModule);
  439.         IO_WriteS(Tree_f, (STRING)"    (Tree: ", 8L);
  440.         Tree_WI(Tree_itTree);
  441.         IO_WriteS(Tree_f, (STRING)");", 2L);
  442.         IO_WriteNl(Tree_f);
  443.       }
  444.       if (Sets_IsElement(ORD('F'), &Tree_Options) && !Sets_IsElement(ORD('<'), &Tree_Options)) {
  445.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Release", 17L);
  446.         Tree_WI(Tree_iModule);
  447.         IO_WriteS(Tree_f, (STRING)"Module;", 7L);
  448.         IO_WriteNl(Tree_f);
  449.       }
  450.       if (Sets_IsElement(ORD('o'), &Tree_Options)) {
  451.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Write", 15L);
  452.         Tree_WI(Tree_iModule);
  453.         IO_WriteS(Tree_f, (STRING)"Node    (f: IO.tFile; Tree: ", 25L);
  454.         Tree_WI(Tree_itTree);
  455.         IO_WriteS(Tree_f, (STRING)");", 2L);
  456.         IO_WriteNl(Tree_f);
  457.       }
  458.       if (Sets_IsElement(ORD('w'), &Tree_Options)) {
  459.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Write", 15L);
  460.         Tree_WI(Tree_iModule);
  461.         IO_WriteS(Tree_f, (STRING)"    (f: IO.tFile; Tree: ", 21L);
  462.         Tree_WI(Tree_itTree);
  463.         IO_WriteS(Tree_f, (STRING)");", 2L);
  464.         IO_WriteNl(Tree_f);
  465.       }
  466.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  467.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Read", 14L);
  468.         Tree_WI(Tree_iModule);
  469.         IO_WriteS(Tree_f, (STRING)"    (f: IO.tFile): ", 16L);
  470.         Tree_WI(Tree_itTree);
  471.         IO_WriteS(Tree_f, (STRING)";", 1L);
  472.         IO_WriteNl(Tree_f);
  473.       }
  474.       if (Sets_IsElement(ORD('p'), &Tree_Options)) {
  475.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Put", 13L);
  476.         Tree_WI(Tree_iModule);
  477.         IO_WriteS(Tree_f, (STRING)"    (f: IO.tFile; Tree: ", 21L);
  478.         Tree_WI(Tree_itTree);
  479.         IO_WriteS(Tree_f, (STRING)");", 2L);
  480.         IO_WriteNl(Tree_f);
  481.       }
  482.       if (Sets_IsElement(ORD('g'), &Tree_Options)) {
  483.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Get", 13L);
  484.         Tree_WI(Tree_iModule);
  485.         IO_WriteS(Tree_f, (STRING)"    (f: IO.tFile): ", 16L);
  486.         Tree_WI(Tree_itTree);
  487.         IO_WriteS(Tree_f, (STRING)";", 1L);
  488.         IO_WriteNl(Tree_f);
  489.       }
  490.       if (Sets_IsElement(ORD('t'), &Tree_Options)) {
  491.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Traverse", 18L);
  492.         Tree_WI(Tree_iModule);
  493.         IO_WriteS(Tree_f, (STRING)"TD    (Tree: ", 10L);
  494.         Tree_WI(Tree_itTree);
  495.         IO_WriteS(Tree_f, (STRING)"; Proc: tProcTree);", 19L);
  496.         IO_WriteNl(Tree_f);
  497.       }
  498.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  499.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Traverse", 18L);
  500.         Tree_WI(Tree_iModule);
  501.         IO_WriteS(Tree_f, (STRING)"BU    (Tree: ", 10L);
  502.         Tree_WI(Tree_itTree);
  503.         IO_WriteS(Tree_f, (STRING)"; Proc: tProcTree);", 19L);
  504.         IO_WriteNl(Tree_f);
  505.       }
  506.       if (Sets_IsElement(ORD('R'), &Tree_Options)) {
  507.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Reverse", 17L);
  508.         Tree_WI(Tree_iModule);
  509.         IO_WriteS(Tree_f, (STRING)"    (Tree: ", 8L);
  510.         Tree_WI(Tree_itTree);
  511.         IO_WriteS(Tree_f, (STRING)"): ", 3L);
  512.         Tree_WI(Tree_itTree);
  513.         IO_WriteS(Tree_f, (STRING)";", 1L);
  514.         IO_WriteNl(Tree_f);
  515.       }
  516.       if (Sets_IsElement(ORD('y'), &Tree_Options)) {
  517.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Copy", 14L);
  518.         Tree_WI(Tree_iModule);
  519.         IO_WriteS(Tree_f, (STRING)"    (Tree: ", 8L);
  520.         Tree_WI(Tree_itTree);
  521.         IO_WriteS(Tree_f, (STRING)"): ", 3L);
  522.         Tree_WI(Tree_itTree);
  523.         IO_WriteS(Tree_f, (STRING)";", 1L);
  524.         IO_WriteNl(Tree_f);
  525.       }
  526.       if (Sets_IsElement(ORD('k'), &Tree_Options)) {
  527.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Check", 15L);
  528.         Tree_WI(Tree_iModule);
  529.         IO_WriteS(Tree_f, (STRING)"    (Tree: ", 8L);
  530.         Tree_WI(Tree_itTree);
  531.         IO_WriteS(Tree_f, (STRING)"): BOOLEAN;", 11L);
  532.         IO_WriteNl(Tree_f);
  533.       }
  534.       if (Sets_IsElement(ORD('q'), &Tree_Options)) {
  535.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Query", 15L);
  536.         Tree_WI(Tree_iModule);
  537.         IO_WriteS(Tree_f, (STRING)"    (Tree: ", 8L);
  538.         Tree_WI(Tree_itTree);
  539.         IO_WriteS(Tree_f, (STRING)");", 2L);
  540.         IO_WriteNl(Tree_f);
  541.       }
  542.       if (Sets_IsElement(ORD('='), &Tree_Options)) {
  543.         IO_WriteS(Tree_f, (STRING)"PROCEDURE IsEqual", 17L);
  544.         Tree_WI(Tree_iModule);
  545.         IO_WriteS(Tree_f, (STRING)"    (Tree1, Tree2: ", 16L);
  546.         Tree_WI(Tree_itTree);
  547.         IO_WriteS(Tree_f, (STRING)"): BOOLEAN;", 11L);
  548.         IO_WriteNl(Tree_f);
  549.       }
  550.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  551.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Init", 14L);
  552.         Tree_WI(Tree_iModule);
  553.         IO_WriteS(Tree_f, (STRING)"    (Tree: ", 8L);
  554.         Tree_WI(Tree_itTree);
  555.         IO_WriteS(Tree_f, (STRING)");", 2L);
  556.         IO_WriteNl(Tree_f);
  557.       }
  558.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Begin", 15L);
  559.       Tree_WI(Tree_iModule);
  560.       IO_WriteS(Tree_f, (STRING)";", 1L);
  561.       IO_WriteNl(Tree_f);
  562.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Close", 15L);
  563.       Tree_WI(Tree_iModule);
  564.       IO_WriteS(Tree_f, (STRING)";", 1L);
  565.       IO_WriteNl(Tree_f);
  566.       IO_WriteNl(Tree_f);
  567.       IO_WriteS(Tree_f, (STRING)"END ", 4L);
  568.       Tree_WI(Tree_iModule);
  569.       IO_WriteS(Tree_f, (STRING)".", 1L);
  570.       IO_WriteNl(Tree_f);
  571.       return;
  572.     }
  573.   }
  574. }
  575.  
  576. static void ConstDecls
  577. # ifdef __STDC__
  578. (Tree_tTree t)
  579. # else
  580. (t)
  581. Tree_tTree t;
  582. # endif
  583. {
  584.   struct S_4 yyTempo;
  585.  
  586.   if (t == Tree_NoTree) {
  587.     return;
  588.   }
  589.   if (t->U_1.V_1.Kind == Tree_Class) {
  590.     {
  591.       register Tree_yClass *W_2 = &t->U_1.V_5.Class;
  592.  
  593.       if (!IN(Tree_Abstract, W_2->Properties)) {
  594.         INC(ConstCount);
  595.         if (!IN(Tree_Ignore, W_2->Properties)) {
  596.           Tree_WI(W_2->Name);
  597.           IO_WriteS(Tree_f, (STRING)" = ", 3L);
  598.           Tree_WN(ConstCount);
  599.           IO_WriteS(Tree_f, (STRING)";", 1L);
  600.           IO_WriteNl(Tree_f);
  601.         }
  602.       }
  603.       return;
  604.     }
  605.   }
  606. }
  607.  
  608. static void TypeDeclNode
  609. # ifdef __STDC__
  610. (Tree_tTree t)
  611. # else
  612. (t)
  613. Tree_tTree t;
  614. # endif
  615. {
  616.   struct S_5 yyTempo;
  617.  
  618.   if (t == Tree_NoTree) {
  619.     return;
  620.   }
  621.   if (t->U_1.V_1.Kind == Tree_Class) {
  622.     {
  623.       register Tree_yClass *W_3 = &t->U_1.V_5.Class;
  624.  
  625.       if ((Tree_NoCodeClass & W_3->Properties) == 0X0L) {
  626.         IO_WriteS(Tree_f, (STRING)"y", 1L);
  627.         Tree_WI(W_3->Name);
  628.         IO_WriteS(Tree_f, (STRING)" = RECORD yyHead: yytNodeHead; ", 31L);
  629.         Tree_ForallAttributes(t, (Tree_ProcOfT)TypeDeclNode);
  630.         IO_WriteS(Tree_f, (STRING)"END;", 4L);
  631.         IO_WriteNl(Tree_f);
  632.       }
  633.       return;
  634.     }
  635.   }
  636.   if (t->U_1.V_1.Kind == Tree_Child) {
  637.     {
  638.       register Tree_yChild *W_4 = &t->U_1.V_9.Child;
  639.  
  640.       Tree_WI(W_4->Name);
  641.       IO_WriteS(Tree_f, (STRING)": ", 2L);
  642.       Tree_WI(Tree_itTree);
  643.       IO_WriteS(Tree_f, (STRING)"; ", 2L);
  644.       return;
  645.     }
  646.   }
  647.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  648.     {
  649.       register Tree_yAttribute *W_5 = &t->U_1.V_10.Attribute;
  650.  
  651.       if ((Tree_NoCodeAttr & W_5->Properties) == 0X0L) {
  652.         Tree_WI(W_5->Name);
  653.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  654.         Tree_WI(W_5->Type);
  655.         IO_WriteS(Tree_f, (STRING)"; ", 2L);
  656.       }
  657.       return;
  658.     }
  659.   }
  660. }
  661.  
  662. static void TypeDeclRecord
  663. # ifdef __STDC__
  664. (Tree_tTree t)
  665. # else
  666. (t)
  667. Tree_tTree t;
  668. # endif
  669. {
  670.   struct S_6 yyTempo;
  671.  
  672.   if (t == Tree_NoTree) {
  673.     return;
  674.   }
  675.   if (t->U_1.V_1.Kind == Tree_Class) {
  676.     {
  677.       register Tree_yClass *W_6 = &t->U_1.V_5.Class;
  678.  
  679.       if ((Tree_NoCodeClass & W_6->Properties) == 0X0L) {
  680.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  681.         Tree_WI(W_6->Name);
  682.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  683.         Tree_WI(W_6->Name);
  684.         IO_WriteS(Tree_f, (STRING)": y", 3L);
  685.         Tree_WI(W_6->Name);
  686.         IO_WriteS(Tree_f, (STRING)";", 1L);
  687.         IO_WriteNl(Tree_f);
  688.       }
  689.       return;
  690.     }
  691.   }
  692. }
  693.  
  694. static void ProcedureDeclsn
  695. # ifdef __STDC__
  696. (Tree_tTree t)
  697. # else
  698. (t)
  699. Tree_tTree t;
  700. # endif
  701. {
  702.   struct S_7 yyTempo;
  703.  
  704.   if (t == Tree_NoTree) {
  705.     return;
  706.   }
  707.   if (t->U_1.V_1.Kind == Tree_Class) {
  708.     {
  709.       register Tree_yClass *W_7 = &t->U_1.V_5.Class;
  710.  
  711.       if ((Tree_NoCodeClass & W_7->Properties) == 0X0L) {
  712.         IO_WriteS(Tree_f, (STRING)"PROCEDURE n", 11L);
  713.         Tree_WI(W_7->Name);
  714.         IO_WriteS(Tree_f, (STRING)" (): ", 5L);
  715.         Tree_WI(Tree_itTree);
  716.         IO_WriteS(Tree_f, (STRING)";", 1L);
  717.         IO_WriteNl(Tree_f);
  718.       }
  719.       return;
  720.     }
  721.   }
  722. }
  723.  
  724. static void ProcedureHeadingm
  725. # ifdef __STDC__
  726. (Tree_tTree t)
  727. # else
  728. (t)
  729. Tree_tTree t;
  730. # endif
  731. {
  732.   struct S_8 yyTempo;
  733.  
  734.   if (t == Tree_NoTree) {
  735.     return;
  736.   }
  737.   if (t->U_1.V_1.Kind == Tree_Class) {
  738.     {
  739.       register Tree_yClass *W_8 = &t->U_1.V_5.Class;
  740.  
  741.       if ((Tree_NoCodeClass & W_8->Properties) == 0X0L) {
  742.         ListCount = 0;
  743.         IO_WriteS(Tree_f, (STRING)"PROCEDURE m", 11L);
  744.         Tree_WI(W_8->Name);
  745.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  746.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureHeadingm);
  747.         IO_WriteS(Tree_f, (STRING)"): ", 3L);
  748.         Tree_WI(Tree_itTree);
  749.         IO_WriteS(Tree_f, (STRING)";", 1L);
  750.         IO_WriteNl(Tree_f);
  751.       }
  752.       return;
  753.     }
  754.   }
  755.   if (t->U_1.V_1.Kind == Tree_Child) {
  756.     {
  757.       register Tree_yChild *W_9 = &t->U_1.V_9.Child;
  758.  
  759.       if (IN(Tree_Input, W_9->Properties)) {
  760.         if (ListCount > 0) {
  761.           IO_WriteS(Tree_f, (STRING)"; ", 2L);
  762.         }
  763.         IO_WriteS(Tree_f, (STRING)"p", 1L);
  764.         Tree_WI(W_9->Name);
  765.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  766.         Tree_WI(Tree_itTree);
  767.         INC(ListCount);
  768.       }
  769.       return;
  770.     }
  771.   }
  772.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  773.     {
  774.       register Tree_yAttribute *W_10 = &t->U_1.V_10.Attribute;
  775.  
  776.       if (IN(Tree_Input, W_10->Properties)) {
  777.         if (ListCount > 0) {
  778.           IO_WriteS(Tree_f, (STRING)"; ", 2L);
  779.         }
  780.         IO_WriteS(Tree_f, (STRING)"p", 1L);
  781.         Tree_WI(W_10->Name);
  782.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  783.         Tree_WI(W_10->Type);
  784.         INC(ListCount);
  785.       }
  786.       return;
  787.     }
  788.   }
  789. }
  790.  
  791. void TreeMod1_TreeImplMod
  792. # ifdef __STDC__
  793. (Tree_tTree t)
  794. # else
  795. (t)
  796. Tree_tTree t;
  797. # endif
  798. {
  799.   struct S_9 yyTempo;
  800.  
  801.   if (t == Tree_NoTree) {
  802.     return;
  803.   }
  804.   if (t->U_1.V_1.Kind == Tree_Ag) {
  805.     {
  806.       register Tree_yAg *W_11 = &t->U_1.V_26.Ag;
  807.  
  808.       IO_WriteS(Tree_f, (STRING)"IMPLEMENTATION MODULE ", 22L);
  809.       Tree_WI(Tree_iModule);
  810.       IO_WriteS(Tree_f, (STRING)";", 1L);
  811.       IO_WriteNl(Tree_f);
  812.       IO_WriteS(Tree_f, (STRING)"# define yyALLOC(ptr, size)    ptr := yyPoolFreePtr; \\", 51L);
  813.       IO_WriteNl(Tree_f);
  814.       IO_WriteS(Tree_f, (STRING)"  IF SYSTEM.ADDRESS (ptr) >= yyPoolMaxPtr THEN ptr := yyAlloc (); END; \\", 72L);
  815.       IO_WriteNl(Tree_f);
  816.       IO_WriteS(Tree_f, (STRING)"  INC (yyPoolFreePtr, size);", 28L);
  817.       IO_WriteNl(Tree_f);
  818.       IO_WriteS(Tree_f, (STRING)"# define yyFREE(ptr, size)    ", 27L);
  819.       IO_WriteNl(Tree_f);
  820.       IO_WriteNl(Tree_f);
  821.       IO_WriteS(Tree_f, (STRING)"IMPORT SYSTEM, System, General, Memory, DynArray, IO, Layout, StringMem, Strings, Idents, Texts, Sets, Positions;", 113L);
  822.       IO_WriteNl(Tree_f);
  823.       if (Sets_IsElement(ORD('<'), &Tree_Options)) {
  824.         IO_WriteS(Tree_f, (STRING)"FROM ", 5L);
  825.         Tree_WI(Tree_iMain);
  826.         IO_WriteS(Tree_f, (STRING)" IMPORT ", 8L);
  827.         Tree_WI(Tree_itTree);
  828.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  829.         Tree_WI(Tree_iNoTree);
  830.         IO_WriteS(Tree_f, (STRING)", tProcTree, Make", 17L);
  831.         Tree_WI(Tree_iMain);
  832.         IO_WriteS(Tree_f, (STRING)", IsType, yyExit,", 17L);
  833.         IO_WriteNl(Tree_f);
  834.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)ImportConst);
  835.         IO_WriteS(Tree_f, (STRING)"yyAlloc, yyPoolFreePtr, yyPoolMaxPtr, yyNodeSize;", 49L);
  836.         IO_WriteNl(Tree_f);
  837.         IO_WriteNl(Tree_f);
  838.       }
  839.       TreeMod2_WriteLine(W_11->TreeCodes->U_1.V_12.Codes.GlobalLine);
  840.       Texts_WriteText(Tree_f, W_11->TreeCodes->U_1.V_12.Codes.Global);
  841.       Node = W_11->Modules;
  842.       while (Node->U_1.V_1.Kind == Tree_Module) {
  843.         TreeMod2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.GlobalLine);
  844.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Global);
  845.         Node = Node->U_1.V_43.Module.Next;
  846.       }
  847.       TreeMod2_WriteLine(W_11->TreeCodes->U_1.V_12.Codes.LocalLine);
  848.       Texts_WriteText(Tree_f, W_11->TreeCodes->U_1.V_12.Codes.Local);
  849.       Node = W_11->Modules;
  850.       while (Node->U_1.V_1.Kind == Tree_Module) {
  851.         TreeMod2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.LocalLine);
  852.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Local);
  853.         Node = Node->U_1.V_43.Module.Next;
  854.       }
  855.       IO_WriteS(Tree_f, (STRING)"# include \"yy", 13L);
  856.       Tree_WI(Tree_iModule);
  857.       IO_WriteS(Tree_f, (STRING)".w\"", 3L);
  858.       IO_WriteNl(Tree_f);
  859.       IO_WriteNl(Tree_f);
  860.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  861.         IO_WriteS(Tree_f, (STRING)"CONST yyBlockSize = 20480;", 26L);
  862.         IO_WriteNl(Tree_f);
  863.         IO_WriteNl(Tree_f);
  864.         IO_WriteS(Tree_f, (STRING)"TYPE", 4L);
  865.         IO_WriteNl(Tree_f);
  866.         IO_WriteS(Tree_f, (STRING)" yytBlockPtr    = POINTER TO yytBlock;", 35L);
  867.         IO_WriteNl(Tree_f);
  868.         IO_WriteS(Tree_f, (STRING)" yytBlock    = RECORD", 18L);
  869.         IO_WriteNl(Tree_f);
  870.         IO_WriteS(Tree_f, (STRING)"             yyBlock    : ARRAY [1..yyBlockSize] OF CHAR;", 48L);
  871.         IO_WriteNl(Tree_f);
  872.         IO_WriteS(Tree_f, (STRING)"             yySuccessor: yytBlockPtr;", 32L);
  873.         IO_WriteNl(Tree_f);
  874.         IO_WriteS(Tree_f, (STRING)"          END;", 8L);
  875.         IO_WriteNl(Tree_f);
  876.         IO_WriteNl(Tree_f);
  877.         IO_WriteS(Tree_f, (STRING)"VAR yyBlockList    : yytBlockPtr;", 30L);
  878.         IO_WriteNl(Tree_f);
  879.         IO_WriteS(Tree_f, (STRING)"VAR yyMaxSize, yyi    : SHORTCARD;", 31L);
  880.         IO_WriteNl(Tree_f);
  881.         IO_WriteS(Tree_f, (STRING)"VAR yyTypeRange    : ARRAY [0..", 28L);
  882.         Tree_WN(Tree_ClassCount);
  883.         IO_WriteS(Tree_f, (STRING)"] OF SHORTCARD;", 15L);
  884.         IO_WriteNl(Tree_f);
  885.         IO_WriteNl(Tree_f);
  886.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyAlloc (): ", 22L);
  887.         Tree_WI(Tree_itTree);
  888.         IO_WriteS(Tree_f, (STRING)";", 1L);
  889.         IO_WriteNl(Tree_f);
  890.         IO_WriteS(Tree_f, (STRING)" VAR yyBlockPtr    : yytBlockPtr;", 30L);
  891.         IO_WriteNl(Tree_f);
  892.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  893.         IO_WriteNl(Tree_f);
  894.         IO_WriteS(Tree_f, (STRING)"  yyBlockPtr    := yyBlockList;", 28L);
  895.         IO_WriteNl(Tree_f);
  896.         IO_WriteS(Tree_f, (STRING)"  yyBlockList    := Memory.Alloc (SYSTEM.TSIZE (yytBlock));", 56L);
  897.         IO_WriteNl(Tree_f);
  898.         IO_WriteS(Tree_f, (STRING)"  yyBlockList^.yySuccessor := yyBlockPtr;", 41L);
  899.         IO_WriteNl(Tree_f);
  900.         IO_WriteS(Tree_f, (STRING)"  yyPoolFreePtr    := SYSTEM.ADR (yyBlockList^.yyBlock);", 53L);
  901.         IO_WriteNl(Tree_f);
  902.         IO_WriteS(Tree_f, (STRING)"  yyPoolMaxPtr    := yyPoolFreePtr + yyBlockSize - yyMaxSize + 1;", 62L);
  903.         IO_WriteNl(Tree_f);
  904.         IO_WriteS(Tree_f, (STRING)"  INC (HeapUsed, yyBlockSize);", 30L);
  905.         IO_WriteNl(Tree_f);
  906.         IO_WriteS(Tree_f, (STRING)"  RETURN yyPoolFreePtr;", 23L);
  907.         IO_WriteNl(Tree_f);
  908.         IO_WriteS(Tree_f, (STRING)" END yyAlloc;", 13L);
  909.         IO_WriteNl(Tree_f);
  910.         IO_WriteNl(Tree_f);
  911.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Make", 14L);
  912.         Tree_WI(Tree_iMain);
  913.         IO_WriteS(Tree_f, (STRING)" (yyKind: SHORTCARD): ", 22L);
  914.         Tree_WI(Tree_itTree);
  915.         IO_WriteS(Tree_f, (STRING)";", 1L);
  916.         IO_WriteNl(Tree_f);
  917.         IO_WriteS(Tree_f, (STRING)" VAR yyByteCount    : LONGINT;", 27L);
  918.         IO_WriteNl(Tree_f);
  919.         IO_WriteS(Tree_f, (STRING)" VAR yyt    : ", 11L);
  920.         Tree_WI(Tree_itTree);
  921.         IO_WriteS(Tree_f, (STRING)";", 1L);
  922.         IO_WriteNl(Tree_f);
  923.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  924.         IO_WriteNl(Tree_f);
  925.         IO_WriteS(Tree_f, (STRING)"  yyALLOC (yyt, yyNodeSize [yyKind])", 36L);
  926.         IO_WriteNl(Tree_f);
  927.         IO_WriteS(Tree_f, (STRING)"  yyt^.yyHead.yyMark := 0;", 26L);
  928.         IO_WriteNl(Tree_f);
  929.         IO_WriteS(Tree_f, (STRING)"  yyt^.Kind := yyKind;", 22L);
  930.         IO_WriteNl(Tree_f);
  931.         IO_WriteS(Tree_f, (STRING)"  RETURN yyt;", 13L);
  932.         IO_WriteNl(Tree_f);
  933.         IO_WriteS(Tree_f, (STRING)" END Make", 9L);
  934.         Tree_WI(Tree_iMain);
  935.         IO_WriteS(Tree_f, (STRING)";", 1L);
  936.         IO_WriteNl(Tree_f);
  937.         IO_WriteNl(Tree_f);
  938.         IO_WriteS(Tree_f, (STRING)"PROCEDURE IsType (yyTree: ", 26L);
  939.         Tree_WI(Tree_itTree);
  940.         IO_WriteS(Tree_f, (STRING)"; yyKind: SHORTCARD): BOOLEAN;", 30L);
  941.         IO_WriteNl(Tree_f);
  942.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  943.         IO_WriteNl(Tree_f);
  944.         IO_WriteS(Tree_f, (STRING)"  RETURN (yyTree # ", 19L);
  945.         Tree_WI(Tree_iNoTree);
  946.         IO_WriteS(Tree_f, (STRING)") AND (yyKind <= yyTree^.Kind) AND (yyTree^.Kind <= yyTypeRange [yyKind]);", 74L);
  947.         IO_WriteNl(Tree_f);
  948.         IO_WriteS(Tree_f, (STRING)" END IsType;", 12L);
  949.         IO_WriteNl(Tree_f);
  950.         IO_WriteNl(Tree_f);
  951.       }
  952.       if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  953.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)ProcedureBodyn);
  954.       }
  955.       IO_WriteNl(Tree_f);
  956.       if (Sets_IsElement(ORD('m'), &Tree_Options)) {
  957.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)ProcedureBodym);
  958.       }
  959.       TreeMod2_TreeIO(t);
  960.       if (Sets_IsElement(ORD('f'), &Tree_Options)) {
  961.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Release", 17L);
  962.         Tree_WI(Tree_iModule);
  963.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  964.         Tree_WI(Tree_itTree);
  965.         IO_WriteS(Tree_f, (STRING)");", 2L);
  966.         IO_WriteNl(Tree_f);
  967.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  968.         IO_WriteNl(Tree_f);
  969.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  970.         IO_WriteNl(Tree_f);
  971.         IO_WriteS(Tree_f, (STRING)"  yyRelease", 11L);
  972.         Tree_WI(Tree_iModule);
  973.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  974.         IO_WriteNl(Tree_f);
  975.         IO_WriteS(Tree_f, (STRING)" END Release", 12L);
  976.         Tree_WI(Tree_iModule);
  977.         IO_WriteS(Tree_f, (STRING)";", 1L);
  978.         IO_WriteNl(Tree_f);
  979.         IO_WriteNl(Tree_f);
  980.         IO_WriteS(Tree_f, (STRING)"VAR yyChild    : ", 14L);
  981.         Tree_WI(Tree_itTree);
  982.         IO_WriteS(Tree_f, (STRING)";", 1L);
  983.         IO_WriteNl(Tree_f);
  984.         IO_WriteNl(Tree_f);
  985.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyRelease", 19L);
  986.         Tree_WI(Tree_iModule);
  987.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  988.         Tree_WI(Tree_itTree);
  989.         IO_WriteS(Tree_f, (STRING)");", 2L);
  990.         IO_WriteNl(Tree_f);
  991.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  992.         IO_WriteNl(Tree_f);
  993.         IO_WriteS(Tree_f, (STRING)"  IF yyt = ", 11L);
  994.         Tree_WI(Tree_iNoTree);
  995.         IO_WriteS(Tree_f, (STRING)" THEN RETURN; END;", 18L);
  996.         IO_WriteNl(Tree_f);
  997.         IO_WriteS(Tree_f, (STRING)"  CASE yyt^.Kind OF", 19L);
  998.         IO_WriteNl(Tree_f);
  999.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)ReleaseAttributes1);
  1000.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  1001.         IO_WriteNl(Tree_f);
  1002.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1003.         IO_WriteNl(Tree_f);
  1004.         IO_WriteNl(Tree_f);
  1005.         IO_WriteS(Tree_f, (STRING)"  DEC (yyt^.yyHead.yyMark);", 27L);
  1006.         IO_WriteNl(Tree_f);
  1007.         IO_WriteS(Tree_f, (STRING)"  IF yyt^.yyHead.yyMark = 0 THEN", 32L);
  1008.         IO_WriteNl(Tree_f);
  1009.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  1010.         IO_WriteNl(Tree_f);
  1011.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)ReleaseAttributes2);
  1012.         IO_WriteS(Tree_f, (STRING)"   ELSE", 7L);
  1013.         IO_WriteNl(Tree_f);
  1014.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1015.         IO_WriteNl(Tree_f);
  1016.         IO_WriteS(Tree_f, (STRING)"   yyFREE (yyt, yyNodeSize [yyt^.Kind])", 39L);
  1017.         IO_WriteNl(Tree_f);
  1018.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1019.         IO_WriteNl(Tree_f);
  1020.         IO_WriteS(Tree_f, (STRING)" END yyRelease", 14L);
  1021.         Tree_WI(Tree_iModule);
  1022.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1023.         IO_WriteNl(Tree_f);
  1024.         IO_WriteNl(Tree_f);
  1025.       }
  1026.       if (Sets_IsElement(ORD('F'), &Tree_Options) && !Sets_IsElement(ORD('<'), &Tree_Options)) {
  1027.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Release", 17L);
  1028.         Tree_WI(Tree_iModule);
  1029.         IO_WriteS(Tree_f, (STRING)"Module;", 7L);
  1030.         IO_WriteNl(Tree_f);
  1031.         IO_WriteS(Tree_f, (STRING)" VAR yyBlockPtr    : yytBlockPtr;", 30L);
  1032.         IO_WriteNl(Tree_f);
  1033.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1034.         IO_WriteNl(Tree_f);
  1035.         IO_WriteS(Tree_f, (STRING)"  WHILE yyBlockList # NIL DO", 28L);
  1036.         IO_WriteNl(Tree_f);
  1037.         IO_WriteS(Tree_f, (STRING)"   yyBlockPtr    := yyBlockList;", 29L);
  1038.         IO_WriteNl(Tree_f);
  1039.         IO_WriteS(Tree_f, (STRING)"   yyBlockList    := yyBlockList^.yySuccessor;", 43L);
  1040.         IO_WriteNl(Tree_f);
  1041.         IO_WriteS(Tree_f, (STRING)"   Memory.Free (SYSTEM.TSIZE (yytBlock), yyBlockPtr);", 53L);
  1042.         IO_WriteNl(Tree_f);
  1043.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1044.         IO_WriteNl(Tree_f);
  1045.         IO_WriteS(Tree_f, (STRING)"  yyPoolFreePtr    := NIL;", 23L);
  1046.         IO_WriteNl(Tree_f);
  1047.         IO_WriteS(Tree_f, (STRING)"  yyPoolMaxPtr    := NIL;", 22L);
  1048.         IO_WriteNl(Tree_f);
  1049.         IO_WriteS(Tree_f, (STRING)"  HeapUsed    := 0;", 16L);
  1050.         IO_WriteNl(Tree_f);
  1051.         IO_WriteS(Tree_f, (STRING)" END Release", 12L);
  1052.         Tree_WI(Tree_iModule);
  1053.         IO_WriteS(Tree_f, (STRING)"Module;", 7L);
  1054.         IO_WriteNl(Tree_f);
  1055.         IO_WriteNl(Tree_f);
  1056.       }
  1057.       if (Sets_IsElement(ORD('t'), &Tree_Options) || Sets_IsElement(ORD('b'), &Tree_Options)) {
  1058.         IO_WriteS(Tree_f, (STRING)"VAR yyProc    : tProcTree;", 23L);
  1059.         IO_WriteNl(Tree_f);
  1060.         IO_WriteNl(Tree_f);
  1061.       }
  1062.       if (Sets_IsElement(ORD('t'), &Tree_Options)) {
  1063.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Traverse", 18L);
  1064.         Tree_WI(Tree_iModule);
  1065.         IO_WriteS(Tree_f, (STRING)"TD (yyt: ", 9L);
  1066.         Tree_WI(Tree_itTree);
  1067.         IO_WriteS(Tree_f, (STRING)"; yyyProc: tProcTree);", 22L);
  1068.         IO_WriteNl(Tree_f);
  1069.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1070.         IO_WriteNl(Tree_f);
  1071.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  1072.         IO_WriteNl(Tree_f);
  1073.         IO_WriteS(Tree_f, (STRING)"  yyProc := yyyProc;", 20L);
  1074.         IO_WriteNl(Tree_f);
  1075.         IO_WriteS(Tree_f, (STRING)"  yyTraverse", 12L);
  1076.         Tree_WI(Tree_iModule);
  1077.         IO_WriteS(Tree_f, (STRING)"TD (yyt);", 9L);
  1078.         IO_WriteNl(Tree_f);
  1079.         IO_WriteS(Tree_f, (STRING)" END Traverse", 13L);
  1080.         Tree_WI(Tree_iModule);
  1081.         IO_WriteS(Tree_f, (STRING)"TD;", 3L);
  1082.         IO_WriteNl(Tree_f);
  1083.         IO_WriteNl(Tree_f);
  1084.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyTraverse", 20L);
  1085.         Tree_WI(Tree_iModule);
  1086.         IO_WriteS(Tree_f, (STRING)"TD (yyt: ", 9L);
  1087.         Tree_WI(Tree_itTree);
  1088.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1089.         IO_WriteNl(Tree_f);
  1090.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1091.         IO_WriteNl(Tree_f);
  1092.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  1093.         IO_WriteNl(Tree_f);
  1094.         IO_WriteS(Tree_f, (STRING)"   IF (yyt = ", 13L);
  1095.         Tree_WI(Tree_iNoTree);
  1096.         IO_WriteS(Tree_f, (STRING)") OR (yyt^.yyHead.yyMark = 0) THEN RETURN; END;", 47L);
  1097.         IO_WriteNl(Tree_f);
  1098.         IO_WriteS(Tree_f, (STRING)"   yyt^.yyHead.yyMark := 0;", 27L);
  1099.         IO_WriteNl(Tree_f);
  1100.         IO_WriteS(Tree_f, (STRING)"   yyProc (yyt);", 16L);
  1101.         IO_WriteNl(Tree_f);
  1102.         IO_WriteNl(Tree_f);
  1103.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  1104.         IO_WriteNl(Tree_f);
  1105.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)TraverseTD);
  1106.         IO_WriteS(Tree_f, (STRING)"   ELSE RETURN;", 15L);
  1107.         IO_WriteNl(Tree_f);
  1108.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1109.         IO_WriteNl(Tree_f);
  1110.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1111.         IO_WriteNl(Tree_f);
  1112.         IO_WriteS(Tree_f, (STRING)" END yyTraverse", 15L);
  1113.         Tree_WI(Tree_iModule);
  1114.         IO_WriteS(Tree_f, (STRING)"TD;", 3L);
  1115.         IO_WriteNl(Tree_f);
  1116.         IO_WriteNl(Tree_f);
  1117.       }
  1118.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  1119.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Traverse", 18L);
  1120.         Tree_WI(Tree_iModule);
  1121.         IO_WriteS(Tree_f, (STRING)"BU (yyt: ", 9L);
  1122.         Tree_WI(Tree_itTree);
  1123.         IO_WriteS(Tree_f, (STRING)"; yyyProc: tProcTree);", 22L);
  1124.         IO_WriteNl(Tree_f);
  1125.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1126.         IO_WriteNl(Tree_f);
  1127.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  1128.         IO_WriteNl(Tree_f);
  1129.         IO_WriteS(Tree_f, (STRING)"  yyProc := yyyProc;", 20L);
  1130.         IO_WriteNl(Tree_f);
  1131.         IO_WriteS(Tree_f, (STRING)"  yyTraverse", 12L);
  1132.         Tree_WI(Tree_iModule);
  1133.         IO_WriteS(Tree_f, (STRING)"BU (yyt);", 9L);
  1134.         IO_WriteNl(Tree_f);
  1135.         IO_WriteS(Tree_f, (STRING)" END Traverse", 13L);
  1136.         Tree_WI(Tree_iModule);
  1137.         IO_WriteS(Tree_f, (STRING)"BU;", 3L);
  1138.         IO_WriteNl(Tree_f);
  1139.         IO_WriteNl(Tree_f);
  1140.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyTraverse", 20L);
  1141.         Tree_WI(Tree_iModule);
  1142.         IO_WriteS(Tree_f, (STRING)"BU (yyt: ", 9L);
  1143.         Tree_WI(Tree_itTree);
  1144.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1145.         IO_WriteNl(Tree_f);
  1146.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1147.         IO_WriteNl(Tree_f);
  1148.         IO_WriteS(Tree_f, (STRING)"  IF (yyt = ", 12L);
  1149.         Tree_WI(Tree_iNoTree);
  1150.         IO_WriteS(Tree_f, (STRING)") OR (yyt^.yyHead.yyMark = 0) THEN RETURN; END;", 47L);
  1151.         IO_WriteNl(Tree_f);
  1152.         IO_WriteS(Tree_f, (STRING)"  yyt^.yyHead.yyMark := 0;", 26L);
  1153.         IO_WriteNl(Tree_f);
  1154.         IO_WriteNl(Tree_f);
  1155.         IO_WriteS(Tree_f, (STRING)"  CASE yyt^.Kind OF", 19L);
  1156.         IO_WriteNl(Tree_f);
  1157.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)TraverseBU);
  1158.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  1159.         IO_WriteNl(Tree_f);
  1160.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1161.         IO_WriteNl(Tree_f);
  1162.         IO_WriteS(Tree_f, (STRING)"  yyProc (yyt);", 15L);
  1163.         IO_WriteNl(Tree_f);
  1164.         IO_WriteS(Tree_f, (STRING)" END yyTraverse", 15L);
  1165.         Tree_WI(Tree_iModule);
  1166.         IO_WriteS(Tree_f, (STRING)"BU;", 3L);
  1167.         IO_WriteNl(Tree_f);
  1168.         IO_WriteNl(Tree_f);
  1169.       }
  1170.       if (Sets_IsElement(ORD('R'), &Tree_Options)) {
  1171.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Reverse", 17L);
  1172.         Tree_WI(Tree_iModule);
  1173.         IO_WriteS(Tree_f, (STRING)" (yyOld: ", 9L);
  1174.         Tree_WI(Tree_itTree);
  1175.         IO_WriteS(Tree_f, (STRING)"): ", 3L);
  1176.         Tree_WI(Tree_itTree);
  1177.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1178.         IO_WriteNl(Tree_f);
  1179.         IO_WriteS(Tree_f, (STRING)" VAR yyNew, yyNext, yyTail    : ", 29L);
  1180.         Tree_WI(Tree_itTree);
  1181.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1182.         IO_WriteNl(Tree_f);
  1183.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1184.         IO_WriteNl(Tree_f);
  1185.         IO_WriteS(Tree_f, (STRING)"  yyNew    := yyOld;", 17L);
  1186.         IO_WriteNl(Tree_f);
  1187.         IO_WriteS(Tree_f, (STRING)"  yyTail    := yyOld;", 18L);
  1188.         IO_WriteNl(Tree_f);
  1189.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  1190.         IO_WriteNl(Tree_f);
  1191.         IO_WriteS(Tree_f, (STRING)"   CASE yyOld^.Kind OF", 22L);
  1192.         IO_WriteNl(Tree_f);
  1193.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)Reverse1);
  1194.         IO_WriteS(Tree_f, (STRING)"   ELSE EXIT;", 13L);
  1195.         IO_WriteNl(Tree_f);
  1196.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1197.         IO_WriteNl(Tree_f);
  1198.         IO_WriteS(Tree_f, (STRING)"   yyNew    := yyOld;", 18L);
  1199.         IO_WriteNl(Tree_f);
  1200.         IO_WriteS(Tree_f, (STRING)"   yyOld    := yyNext;", 19L);
  1201.         IO_WriteNl(Tree_f);
  1202.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1203.         IO_WriteNl(Tree_f);
  1204.         IO_WriteS(Tree_f, (STRING)"  CASE yyTail^.Kind OF", 22L);
  1205.         IO_WriteNl(Tree_f);
  1206.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)Reverse2);
  1207.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  1208.         IO_WriteNl(Tree_f);
  1209.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1210.         IO_WriteNl(Tree_f);
  1211.         IO_WriteS(Tree_f, (STRING)"  RETURN yyNew;", 15L);
  1212.         IO_WriteNl(Tree_f);
  1213.         IO_WriteS(Tree_f, (STRING)" END Reverse", 12L);
  1214.         Tree_WI(Tree_iModule);
  1215.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1216.         IO_WriteNl(Tree_f);
  1217.         IO_WriteNl(Tree_f);
  1218.       }
  1219.       if (Sets_IsElement(ORD('y'), &Tree_Options)) {
  1220.         IO_WriteS(Tree_f, (STRING)"CONST yyInitOldToNewStoreSize    = 32;", 35L);
  1221.         IO_WriteNl(Tree_f);
  1222.         IO_WriteNl(Tree_f);
  1223.         IO_WriteS(Tree_f, (STRING)"TYPE yytOldToNew = RECORD yyOld, yyNew: ", 40L);
  1224.         Tree_WI(Tree_itTree);
  1225.         IO_WriteS(Tree_f, (STRING)"; END;", 6L);
  1226.         IO_WriteNl(Tree_f);
  1227.         IO_WriteNl(Tree_f);
  1228.         IO_WriteS(Tree_f, (STRING)"VAR yyOldToNewStoreSize    : LONGINT;", 34L);
  1229.         IO_WriteNl(Tree_f);
  1230.         IO_WriteS(Tree_f, (STRING)"VAR yyOldToNewStorePtr    : POINTER TO ARRAY [0..50000] OF yytOldToNew;", 68L);
  1231.         IO_WriteNl(Tree_f);
  1232.         IO_WriteS(Tree_f, (STRING)"VAR yyOldToNewCount    : INTEGER;", 30L);
  1233.         IO_WriteNl(Tree_f);
  1234.         IO_WriteNl(Tree_f);
  1235.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyStoreOldToNew (yyOld, yyNew: ", 41L);
  1236.         Tree_WI(Tree_itTree);
  1237.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1238.         IO_WriteNl(Tree_f);
  1239.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1240.         IO_WriteNl(Tree_f);
  1241.         IO_WriteS(Tree_f, (STRING)"  INC (yyOldToNewCount);", 24L);
  1242.         IO_WriteNl(Tree_f);
  1243.         IO_WriteS(Tree_f, (STRING)"  IF (yyOldToNewCount = yyOldToNewStoreSize) THEN", 49L);
  1244.         IO_WriteNl(Tree_f);
  1245.         IO_WriteS(Tree_f, (STRING)"   DynArray.ExtendArray (yyOldToNewStorePtr, yyOldToNewStoreSize, SYSTEM.TSIZE (yytOldToNew));", 94L);
  1246.         IO_WriteNl(Tree_f);
  1247.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1248.         IO_WriteNl(Tree_f);
  1249.         IO_WriteS(Tree_f, (STRING)"  yyOldToNewStorePtr^[yyOldToNewCount].yyOld := yyOld;", 54L);
  1250.         IO_WriteNl(Tree_f);
  1251.         IO_WriteS(Tree_f, (STRING)"  yyOldToNewStorePtr^[yyOldToNewCount].yyNew := yyNew;", 54L);
  1252.         IO_WriteNl(Tree_f);
  1253.         IO_WriteS(Tree_f, (STRING)" END yyStoreOldToNew;", 21L);
  1254.         IO_WriteNl(Tree_f);
  1255.         IO_WriteNl(Tree_f);
  1256.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyMapOldToNew (yyOld: ", 32L);
  1257.         Tree_WI(Tree_itTree);
  1258.         IO_WriteS(Tree_f, (STRING)"): ", 3L);
  1259.         Tree_WI(Tree_itTree);
  1260.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1261.         IO_WriteNl(Tree_f);
  1262.         IO_WriteS(Tree_f, (STRING)" VAR yyi: INTEGER;", 18L);
  1263.         IO_WriteNl(Tree_f);
  1264.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1265.         IO_WriteNl(Tree_f);
  1266.         IO_WriteS(Tree_f, (STRING)"  FOR yyi := 1 TO yyOldToNewCount DO", 36L);
  1267.         IO_WriteNl(Tree_f);
  1268.         IO_WriteS(Tree_f, (STRING)"   IF yyOldToNewStorePtr^[yyi].yyOld = yyOld THEN", 49L);
  1269.         IO_WriteNl(Tree_f);
  1270.         IO_WriteS(Tree_f, (STRING)"    RETURN yyOldToNewStorePtr^[yyi].yyNew;", 42L);
  1271.         IO_WriteNl(Tree_f);
  1272.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1273.         IO_WriteNl(Tree_f);
  1274.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1275.         IO_WriteNl(Tree_f);
  1276.         IO_WriteS(Tree_f, (STRING)" END yyMapOldToNew;", 19L);
  1277.         IO_WriteNl(Tree_f);
  1278.         IO_WriteNl(Tree_f);
  1279.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyCopy", 16L);
  1280.         Tree_WI(Tree_iModule);
  1281.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1282.         Tree_WI(Tree_itTree);
  1283.         IO_WriteS(Tree_f, (STRING)"; yyNew: yyPtrtTree);", 21L);
  1284.         IO_WriteNl(Tree_f);
  1285.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1286.         IO_WriteNl(Tree_f);
  1287.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  1288.         IO_WriteNl(Tree_f);
  1289.         IO_WriteS(Tree_f, (STRING)"   IF yyt = ", 12L);
  1290.         Tree_WI(Tree_iNoTree);
  1291.         IO_WriteS(Tree_f, (STRING)" THEN yyNew^ := ", 16L);
  1292.         Tree_WI(Tree_iNoTree);
  1293.         IO_WriteS(Tree_f, (STRING)"; RETURN; END;", 14L);
  1294.         IO_WriteNl(Tree_f);
  1295.         IO_WriteS(Tree_f, (STRING)"   IF yyt^.yyHead.yyMark = 0 THEN yyNew^ := yyMapOldToNew (yyt); RETURN; END;", 77L);
  1296.         IO_WriteNl(Tree_f);
  1297.         IO_WriteS(Tree_f, (STRING)"   yyNew^ := Make", 17L);
  1298.         Tree_WI(Tree_iMain);
  1299.         IO_WriteS(Tree_f, (STRING)" (yyt^.Kind);", 13L);
  1300.         IO_WriteNl(Tree_f);
  1301.         IO_WriteS(Tree_f, (STRING)"   IF yyt^.yyHead.yyMark > 1 THEN yyStoreOldToNew (yyt, yyNew^); END;", 69L);
  1302.         IO_WriteNl(Tree_f);
  1303.         IO_WriteS(Tree_f, (STRING)"   yyt^.yyHead.yyMark := 0;", 27L);
  1304.         IO_WriteNl(Tree_f);
  1305.         IO_WriteNl(Tree_f);
  1306.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  1307.         IO_WriteNl(Tree_f);
  1308.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)Copy);
  1309.         IO_WriteS(Tree_f, (STRING)"   ELSE", 7L);
  1310.         IO_WriteNl(Tree_f);
  1311.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1312.         IO_WriteNl(Tree_f);
  1313.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1314.         IO_WriteNl(Tree_f);
  1315.         IO_WriteS(Tree_f, (STRING)" END yyCopy", 11L);
  1316.         Tree_WI(Tree_iModule);
  1317.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1318.         IO_WriteNl(Tree_f);
  1319.         IO_WriteNl(Tree_f);
  1320.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Copy", 14L);
  1321.         Tree_WI(Tree_iModule);
  1322.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1323.         Tree_WI(Tree_itTree);
  1324.         IO_WriteS(Tree_f, (STRING)"): ", 3L);
  1325.         Tree_WI(Tree_itTree);
  1326.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1327.         IO_WriteNl(Tree_f);
  1328.         IO_WriteS(Tree_f, (STRING)" VAR yyNew    : ", 13L);
  1329.         Tree_WI(Tree_itTree);
  1330.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1331.         IO_WriteNl(Tree_f);
  1332.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1333.         IO_WriteNl(Tree_f);
  1334.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  1335.         IO_WriteNl(Tree_f);
  1336.         IO_WriteS(Tree_f, (STRING)"  yyOldToNewCount := 0;", 23L);
  1337.         IO_WriteNl(Tree_f);
  1338.         IO_WriteS(Tree_f, (STRING)"  yyCopy", 8L);
  1339.         Tree_WI(Tree_iModule);
  1340.         IO_WriteS(Tree_f, (STRING)" (yyt, SYSTEM.ADR (yyNew));", 27L);
  1341.         IO_WriteNl(Tree_f);
  1342.         IO_WriteS(Tree_f, (STRING)"  RETURN yyNew;", 15L);
  1343.         IO_WriteNl(Tree_f);
  1344.         IO_WriteS(Tree_f, (STRING)" END Copy", 9L);
  1345.         Tree_WI(Tree_iModule);
  1346.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1347.         IO_WriteNl(Tree_f);
  1348.         IO_WriteNl(Tree_f);
  1349.       }
  1350.       if (Sets_IsElement(ORD('k'), &Tree_Options)) {
  1351.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Check", 15L);
  1352.         Tree_WI(Tree_iModule);
  1353.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1354.         Tree_WI(Tree_itTree);
  1355.         IO_WriteS(Tree_f, (STRING)"): BOOLEAN;", 11L);
  1356.         IO_WriteNl(Tree_f);
  1357.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1358.         IO_WriteNl(Tree_f);
  1359.         IO_WriteS(Tree_f, (STRING)"  yyMark (yyt);", 15L);
  1360.         IO_WriteNl(Tree_f);
  1361.         IO_WriteS(Tree_f, (STRING)"  RETURN yyCheck", 16L);
  1362.         Tree_WI(Tree_iModule);
  1363.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  1364.         IO_WriteNl(Tree_f);
  1365.         IO_WriteS(Tree_f, (STRING)" END Check", 10L);
  1366.         Tree_WI(Tree_iModule);
  1367.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1368.         IO_WriteNl(Tree_f);
  1369.         IO_WriteNl(Tree_f);
  1370.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyCheckChild (yyParent, yyChild: ", 43L);
  1371.         Tree_WI(Tree_itTree);
  1372.         IO_WriteS(Tree_f, (STRING)"; yyType: SHORTCARD; yySelector: ARRAY OF CHAR): BOOLEAN;", 57L);
  1373.         IO_WriteNl(Tree_f);
  1374.         IO_WriteS(Tree_f, (STRING)" CONST yyf    = IO.StdError;", 25L);
  1375.         IO_WriteNl(Tree_f);
  1376.         IO_WriteS(Tree_f, (STRING)" VAR yySuccess    : BOOLEAN;", 25L);
  1377.         IO_WriteNl(Tree_f);
  1378.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1379.         IO_WriteNl(Tree_f);
  1380.         IO_WriteS(Tree_f, (STRING)"  yySuccess := IsType (yyChild, yyType);", 40L);
  1381.         IO_WriteNl(Tree_f);
  1382.         IO_WriteS(Tree_f, (STRING)"  IF NOT yySuccess THEN", 23L);
  1383.         IO_WriteNl(Tree_f);
  1384.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (yyf, 'CheckTree: parent = ');", 43L);
  1385.         IO_WriteNl(Tree_f);
  1386.         IO_WriteS(Tree_f, (STRING)"   Write", 8L);
  1387.         Tree_WI(Tree_iModule);
  1388.         IO_WriteS(Tree_f, (STRING)"Node (yyf, yyParent);", 21L);
  1389.         IO_WriteNl(Tree_f);
  1390.         IO_WriteS(Tree_f, (STRING)"   IO.WriteNl (yyf);", 20L);
  1391.         IO_WriteNl(Tree_f);
  1392.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (yyf, 'selector: ');", 33L);
  1393.         IO_WriteNl(Tree_f);
  1394.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (yyf, yySelector);", 31L);
  1395.         IO_WriteNl(Tree_f);
  1396.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (yyf, ', child = ');", 33L);
  1397.         IO_WriteNl(Tree_f);
  1398.         IO_WriteS(Tree_f, (STRING)"   Write", 8L);
  1399.         Tree_WI(Tree_iModule);
  1400.         IO_WriteS(Tree_f, (STRING)"Node (yyf, yyChild);", 20L);
  1401.         IO_WriteNl(Tree_f);
  1402.         IO_WriteS(Tree_f, (STRING)"   IO.WriteNl (yyf);", 20L);
  1403.         IO_WriteNl(Tree_f);
  1404.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1405.         IO_WriteNl(Tree_f);
  1406.         IO_WriteS(Tree_f, (STRING)"  RETURN yyCheck", 16L);
  1407.         Tree_WI(Tree_iModule);
  1408.         IO_WriteS(Tree_f, (STRING)" (yyChild) AND yySuccess;", 25L);
  1409.         IO_WriteNl(Tree_f);
  1410.         IO_WriteS(Tree_f, (STRING)" END yyCheckChild;", 18L);
  1411.         IO_WriteNl(Tree_f);
  1412.         IO_WriteNl(Tree_f);
  1413.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyCheck", 17L);
  1414.         Tree_WI(Tree_iModule);
  1415.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1416.         Tree_WI(Tree_itTree);
  1417.         IO_WriteS(Tree_f, (STRING)"): BOOLEAN;", 11L);
  1418.         IO_WriteNl(Tree_f);
  1419.         IO_WriteS(Tree_f, (STRING)" VAR yyResult    : BOOLEAN;", 24L);
  1420.         IO_WriteNl(Tree_f);
  1421.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1422.         IO_WriteNl(Tree_f);
  1423.         IO_WriteS(Tree_f, (STRING)"  IF yyt = ", 11L);
  1424.         Tree_WI(Tree_iNoTree);
  1425.         IO_WriteS(Tree_f, (STRING)" THEN RETURN FALSE;", 19L);
  1426.         IO_WriteNl(Tree_f);
  1427.         IO_WriteS(Tree_f, (STRING)"  ELSIF yyt^.yyHead.yyMark = 0 THEN RETURN TRUE;", 48L);
  1428.         IO_WriteNl(Tree_f);
  1429.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1430.         IO_WriteNl(Tree_f);
  1431.         IO_WriteS(Tree_f, (STRING)"  yyt^.yyHead.yyMark := 0;", 26L);
  1432.         IO_WriteNl(Tree_f);
  1433.         IO_WriteNl(Tree_f);
  1434.         IO_WriteS(Tree_f, (STRING)"  yyResult := TRUE;", 19L);
  1435.         IO_WriteNl(Tree_f);
  1436.         IO_WriteS(Tree_f, (STRING)"  CASE yyt^.Kind OF", 19L);
  1437.         IO_WriteNl(Tree_f);
  1438.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)CheckAttributes);
  1439.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  1440.         IO_WriteNl(Tree_f);
  1441.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1442.         IO_WriteNl(Tree_f);
  1443.         IO_WriteS(Tree_f, (STRING)"  RETURN yyResult;", 18L);
  1444.         IO_WriteNl(Tree_f);
  1445.         IO_WriteS(Tree_f, (STRING)" END yyCheck", 12L);
  1446.         Tree_WI(Tree_iModule);
  1447.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1448.         IO_WriteNl(Tree_f);
  1449.         IO_WriteNl(Tree_f);
  1450.       }
  1451.       if (Sets_IsElement(ORD('q'), &Tree_Options)) {
  1452.         IO_WriteS(Tree_f, (STRING)"CONST yyyWrite = 1; yyyRead = 2; yyyQuit = 3;", 45L);
  1453.         IO_WriteNl(Tree_f);
  1454.         IO_WriteNl(Tree_f);
  1455.         IO_WriteS(Tree_f, (STRING)"VAR yyString    : ARRAY [0..31] OF CHAR;", 37L);
  1456.         IO_WriteNl(Tree_f);
  1457.         IO_WriteS(Tree_f, (STRING)"VAR yyLength    : INTEGER;", 23L);
  1458.         IO_WriteNl(Tree_f);
  1459.         IO_WriteS(Tree_f, (STRING)"VAR yyCh    : CHAR;", 16L);
  1460.         IO_WriteNl(Tree_f);
  1461.         IO_WriteS(Tree_f, (STRING)"VAR yyState    : INTEGER;", 22L);
  1462.         IO_WriteNl(Tree_f);
  1463.         IO_WriteNl(Tree_f);
  1464.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyyIsEqual (yya: ARRAY OF CHAR): BOOLEAN;", 51L);
  1465.         IO_WriteNl(Tree_f);
  1466.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  1467.         IO_WriteNl(Tree_f);
  1468.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1469.         IO_WriteNl(Tree_f);
  1470.         IO_WriteS(Tree_f, (STRING)"  IF (yyLength >= 0) AND (yyString [yyLength] = ' ') THEN", 57L);
  1471.         IO_WriteNl(Tree_f);
  1472.         IO_WriteS(Tree_f, (STRING)"   IF yyLength - 1 # INTEGER (HIGH (yya)) THEN RETURN FALSE; END;", 65L);
  1473.         IO_WriteNl(Tree_f);
  1474.         IO_WriteS(Tree_f, (STRING)"   FOR yyi := 0 TO yyLength - 1 DO", 34L);
  1475.         IO_WriteNl(Tree_f);
  1476.         IO_WriteS(Tree_f, (STRING)"    IF yyString [yyi] # yya [yyi] THEN RETURN FALSE; END;", 57L);
  1477.         IO_WriteNl(Tree_f);
  1478.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1479.         IO_WriteNl(Tree_f);
  1480.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  1481.         IO_WriteNl(Tree_f);
  1482.         IO_WriteS(Tree_f, (STRING)"   IF yyLength > INTEGER (HIGH (yya)) THEN RETURN FALSE; END;", 61L);
  1483.         IO_WriteNl(Tree_f);
  1484.         IO_WriteS(Tree_f, (STRING)"   FOR yyi := 0 TO yyLength DO", 30L);
  1485.         IO_WriteNl(Tree_f);
  1486.         IO_WriteS(Tree_f, (STRING)"    IF yyString [yyi] # yya [yyi] THEN RETURN FALSE; END;", 57L);
  1487.         IO_WriteNl(Tree_f);
  1488.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1489.         IO_WriteNl(Tree_f);
  1490.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1491.         IO_WriteNl(Tree_f);
  1492.         IO_WriteS(Tree_f, (STRING)"  RETURN TRUE;", 14L);
  1493.         IO_WriteNl(Tree_f);
  1494.         IO_WriteS(Tree_f, (STRING)" END yyyIsEqual;", 16L);
  1495.         IO_WriteNl(Tree_f);
  1496.         IO_WriteNl(Tree_f);
  1497.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Query", 15L);
  1498.         Tree_WI(Tree_iModule);
  1499.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1500.         Tree_WI(Tree_itTree);
  1501.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1502.         IO_WriteNl(Tree_f);
  1503.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1504.         IO_WriteNl(Tree_f);
  1505.         IO_WriteS(Tree_f, (STRING)"  yyState := yyyWrite;", 22L);
  1506.         IO_WriteNl(Tree_f);
  1507.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  1508.         IO_WriteNl(Tree_f);
  1509.         IO_WriteS(Tree_f, (STRING)"   CASE yyState OF", 18L);
  1510.         IO_WriteNl(Tree_f);
  1511.         IO_WriteS(Tree_f, (STRING)"   | yyyQuit    : RETURN;", 22L);
  1512.         IO_WriteNl(Tree_f);
  1513.         IO_WriteS(Tree_f, (STRING)"   | yyyWrite    : Write", 21L);
  1514.         Tree_WI(Tree_iModule);
  1515.         IO_WriteS(Tree_f, (STRING)"Node (IO.StdOutput, yyt); yyState := yyyRead;", 45L);
  1516.         IO_WriteNl(Tree_f);
  1517.         IO_WriteS(Tree_f, (STRING)"   | yyyRead    : IO.WriteS (IO.StdOutput, '? '); yyLength := -1; yyCh := IO.ReadC (IO.StdInput);", 94L);
  1518.         IO_WriteNl(Tree_f);
  1519.         IO_WriteS(Tree_f, (STRING)"    WHILE yyCh # 12C DO INC (yyLength); yyString [yyLength] := yyCh; yyCh := IO.ReadC (IO.StdInput); END;", 105L);
  1520.         IO_WriteNl(Tree_f);
  1521.         IO_WriteS(Tree_f, (STRING)"    IF    yyyIsEqual ('parent') THEN yyState := yyyWrite; RETURN;", 65L);
  1522.         IO_WriteNl(Tree_f);
  1523.         IO_WriteS(Tree_f, (STRING)"    ELSIF yyyIsEqual ('quit'  ) THEN yyState := yyyQuit ; RETURN;", 65L);
  1524.         IO_WriteNl(Tree_f);
  1525.         IO_WriteS(Tree_f, (STRING)"    ELSIF yyt # ", 16L);
  1526.         Tree_WI(Tree_iNoTree);
  1527.         IO_WriteS(Tree_f, (STRING)" THEN", 5L);
  1528.         IO_WriteNl(Tree_f);
  1529.         IO_WriteS(Tree_f, (STRING)"     CASE yyt^.Kind OF", 22L);
  1530.         IO_WriteNl(Tree_f);
  1531.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)QueryAttributes);
  1532.         IO_WriteS(Tree_f, (STRING)"     ELSE", 9L);
  1533.         IO_WriteNl(Tree_f);
  1534.         IO_WriteS(Tree_f, (STRING)"     END;", 9L);
  1535.         IO_WriteNl(Tree_f);
  1536.         IO_WriteS(Tree_f, (STRING)"    END;", 8L);
  1537.         IO_WriteNl(Tree_f);
  1538.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1539.         IO_WriteNl(Tree_f);
  1540.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1541.         IO_WriteNl(Tree_f);
  1542.         IO_WriteS(Tree_f, (STRING)" END Query", 10L);
  1543.         Tree_WI(Tree_iModule);
  1544.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1545.         IO_WriteNl(Tree_f);
  1546.         IO_WriteNl(Tree_f);
  1547.       }
  1548.       if (Sets_IsElement(ORD('='), &Tree_Options)) {
  1549.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;", 62L);
  1550.         IO_WriteNl(Tree_f);
  1551.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  1552.         IO_WriteNl(Tree_f);
  1553.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1554.         IO_WriteNl(Tree_f);
  1555.         IO_WriteS(Tree_f, (STRING)"  FOR yyi := 0 TO INTEGER (HIGH (yya)) DO", 41L);
  1556.         IO_WriteNl(Tree_f);
  1557.         IO_WriteS(Tree_f, (STRING)"   IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;", 51L);
  1558.         IO_WriteNl(Tree_f);
  1559.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1560.         IO_WriteNl(Tree_f);
  1561.         IO_WriteS(Tree_f, (STRING)"  RETURN TRUE;", 14L);
  1562.         IO_WriteNl(Tree_f);
  1563.         IO_WriteS(Tree_f, (STRING)" END yyIsEqual;", 15L);
  1564.         IO_WriteNl(Tree_f);
  1565.         IO_WriteNl(Tree_f);
  1566.         IO_WriteS(Tree_f, (STRING)"PROCEDURE IsEqual", 17L);
  1567.         Tree_WI(Tree_iModule);
  1568.         IO_WriteS(Tree_f, (STRING)" (yyt1, yyt2: ", 14L);
  1569.         Tree_WI(Tree_itTree);
  1570.         IO_WriteS(Tree_f, (STRING)"): BOOLEAN;", 11L);
  1571.         IO_WriteNl(Tree_f);
  1572.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1573.         IO_WriteNl(Tree_f);
  1574.         IO_WriteS(Tree_f, (STRING)"  IF yyt1 = yyt2 THEN RETURN TRUE; END;", 39L);
  1575.         IO_WriteNl(Tree_f);
  1576.         IO_WriteS(Tree_f, (STRING)"  IF (yyt1 = ", 13L);
  1577.         Tree_WI(Tree_iNoTree);
  1578.         IO_WriteS(Tree_f, (STRING)") OR (yyt2 = ", 13L);
  1579.         Tree_WI(Tree_iNoTree);
  1580.         IO_WriteS(Tree_f, (STRING)") OR (yyt1^.Kind # yyt2^.Kind) THEN RETURN FALSE; END;", 54L);
  1581.         IO_WriteNl(Tree_f);
  1582.         IO_WriteS(Tree_f, (STRING)"  CASE yyt1^.Kind OF", 20L);
  1583.         IO_WriteNl(Tree_f);
  1584.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)IsEqualAttributes);
  1585.         IO_WriteS(Tree_f, (STRING)"  ELSE RETURN TRUE;", 19L);
  1586.         IO_WriteNl(Tree_f);
  1587.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1588.         IO_WriteNl(Tree_f);
  1589.         IO_WriteS(Tree_f, (STRING)" END IsEqual", 12L);
  1590.         Tree_WI(Tree_iModule);
  1591.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1592.         IO_WriteNl(Tree_f);
  1593.         IO_WriteNl(Tree_f);
  1594.       }
  1595.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  1596.         MaxBit = 0;
  1597.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)CompMaxBit);
  1598.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Init", 14L);
  1599.         Tree_WI(Tree_iModule);
  1600.         IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  1601.         Tree_WI(Tree_itTree);
  1602.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1603.         IO_WriteNl(Tree_f);
  1604.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1605.         IO_WriteNl(Tree_f);
  1606.         IO_WriteS(Tree_f, (STRING)"  LOOP", 6L);
  1607.         IO_WriteNl(Tree_f);
  1608.         {
  1609.           SHORTCARD B_5 = 0, B_6 = (MaxBit - 1) / TreeMod1_BSS;
  1610.  
  1611.           if (B_5 <= B_6)
  1612.             for (i = B_5;; i += 1) {
  1613.               IO_WriteS(Tree_f, (STRING)"   yyt^.yyHead.yyIsComp", 23L);
  1614.               Tree_WN((LONGINT)i);
  1615.               IO_WriteS(Tree_f, (STRING)" := {};", 7L);
  1616.               IO_WriteNl(Tree_f);
  1617.               if (Sets_IsElement(ORD('5'), &Tree_Options)) {
  1618.                 IO_WriteS(Tree_f, (STRING)"   yyt^.yyHead.yyIsDone", 23L);
  1619.                 Tree_WN((LONGINT)i);
  1620.                 IO_WriteS(Tree_f, (STRING)" := {};", 7L);
  1621.                 IO_WriteNl(Tree_f);
  1622.               }
  1623.               if (i >= B_6) break;
  1624.             }
  1625.         }
  1626.         IO_WriteS(Tree_f, (STRING)"   CASE yyt^.Kind OF", 20L);
  1627.         IO_WriteNl(Tree_f);
  1628.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)InitAttributes);
  1629.         IO_WriteS(Tree_f, (STRING)"   ELSE RETURN;", 15L);
  1630.         IO_WriteNl(Tree_f);
  1631.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  1632.         IO_WriteNl(Tree_f);
  1633.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1634.         IO_WriteNl(Tree_f);
  1635.         IO_WriteS(Tree_f, (STRING)" END Init", 9L);
  1636.         Tree_WI(Tree_iModule);
  1637.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1638.         IO_WriteNl(Tree_f);
  1639.         IO_WriteNl(Tree_f);
  1640.       }
  1641.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Begin", 15L);
  1642.       Tree_WI(Tree_iModule);
  1643.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1644.       IO_WriteNl(Tree_f);
  1645.       IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1646.       IO_WriteNl(Tree_f);
  1647.       TreeMod2_WriteLine(W_11->TreeCodes->U_1.V_12.Codes.BeginLine);
  1648.       Texts_WriteText(Tree_f, W_11->TreeCodes->U_1.V_12.Codes.Begin);
  1649.       Node = W_11->Modules;
  1650.       while (Node->U_1.V_1.Kind == Tree_Module) {
  1651.         TreeMod2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.BeginLine);
  1652.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Begin);
  1653.         Node = Node->U_1.V_43.Module.Next;
  1654.       }
  1655.       IO_WriteS(Tree_f, (STRING)" END Begin", 10L);
  1656.       Tree_WI(Tree_iModule);
  1657.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1658.       IO_WriteNl(Tree_f);
  1659.       IO_WriteNl(Tree_f);
  1660.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Close", 15L);
  1661.       Tree_WI(Tree_iModule);
  1662.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1663.       IO_WriteNl(Tree_f);
  1664.       IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1665.       IO_WriteNl(Tree_f);
  1666.       TreeMod2_WriteLine(W_11->TreeCodes->U_1.V_12.Codes.CloseLine);
  1667.       Texts_WriteText(Tree_f, W_11->TreeCodes->U_1.V_12.Codes.Close);
  1668.       Node = W_11->Modules;
  1669.       while (Node->U_1.V_1.Kind == Tree_Module) {
  1670.         TreeMod2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.CloseLine);
  1671.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Close);
  1672.         Node = Node->U_1.V_43.Module.Next;
  1673.       }
  1674.       IO_WriteS(Tree_f, (STRING)" END Close", 10L);
  1675.       Tree_WI(Tree_iModule);
  1676.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1677.       IO_WriteNl(Tree_f);
  1678.       IO_WriteNl(Tree_f);
  1679.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  1680.         IO_WriteS(Tree_f, (STRING)"PROCEDURE xxExit;", 17L);
  1681.         IO_WriteNl(Tree_f);
  1682.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1683.         IO_WriteNl(Tree_f);
  1684.         IO_WriteS(Tree_f, (STRING)"  IO.CloseIO; System.Exit (1);", 30L);
  1685.         IO_WriteNl(Tree_f);
  1686.         IO_WriteS(Tree_f, (STRING)" END xxExit;", 12L);
  1687.         IO_WriteNl(Tree_f);
  1688.         IO_WriteNl(Tree_f);
  1689.       }
  1690.       IO_WriteS(Tree_f, (STRING)"BEGIN", 5L);
  1691.       IO_WriteNl(Tree_f);
  1692.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  1693.         IO_WriteS(Tree_f, (STRING)" yyIsInitialized := FALSE;", 26L);
  1694.         IO_WriteNl(Tree_f);
  1695.       }
  1696.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  1697.         IO_WriteS(Tree_f, (STRING)" yyBlockList    := NIL;", 20L);
  1698.         IO_WriteNl(Tree_f);
  1699.         IO_WriteS(Tree_f, (STRING)" yyPoolFreePtr    := NIL;", 22L);
  1700.         IO_WriteNl(Tree_f);
  1701.         IO_WriteS(Tree_f, (STRING)" yyPoolMaxPtr    := NIL;", 21L);
  1702.         IO_WriteNl(Tree_f);
  1703.         IO_WriteS(Tree_f, (STRING)" HeapUsed    := 0;", 15L);
  1704.         IO_WriteNl(Tree_f);
  1705.         IO_WriteS(Tree_f, (STRING)" yyExit    := xxExit;", 18L);
  1706.         IO_WriteNl(Tree_f);
  1707.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)InitNodeSize);
  1708.         IO_WriteS(Tree_f, (STRING)" yyMaxSize    := 0;", 16L);
  1709.         IO_WriteNl(Tree_f);
  1710.         IO_WriteS(Tree_f, (STRING)" FOR yyi := 1 TO ", 17L);
  1711.         Tree_WN(Tree_ClassCount);
  1712.         IO_WriteS(Tree_f, (STRING)" DO", 3L);
  1713.         IO_WriteNl(Tree_f);
  1714.         IO_WriteS(Tree_f, (STRING)"  yyNodeSize [yyi] := LONGINT (BITSET (yyNodeSize [yyi] + CARDINAL (General.MaxAlign) - 1) * General.AlignMasks [General.MaxAlign]);", 132L);
  1715.         IO_WriteNl(Tree_f);
  1716.         IO_WriteS(Tree_f, (STRING)"  yyMaxSize := General.Max (yyNodeSize [yyi], yyMaxSize);", 57L);
  1717.         IO_WriteNl(Tree_f);
  1718.         IO_WriteS(Tree_f, (STRING)" END;", 5L);
  1719.         IO_WriteNl(Tree_f);
  1720.         Tree_ForallClasses(W_11->Classes, (Tree_ProcOfT)InitTypeRange);
  1721.       }
  1722.       if (Sets_IsElement(ORD(';'), &Tree_Options)) {
  1723.         IO_WriteS(Tree_f, (STRING)" yyRecursionLevel := 0;", 23L);
  1724.         IO_WriteNl(Tree_f);
  1725.         IO_WriteS(Tree_f, (STRING)" yyTreeStoreSize := yyInitTreeStoreSize;", 40L);
  1726.         IO_WriteNl(Tree_f);
  1727.         IO_WriteS(Tree_f, (STRING)" DynArray.MakeArray (yyTreeStorePtr, yyTreeStoreSize, SYSTEM.TSIZE (", 68L);
  1728.         Tree_WI(Tree_itTree);
  1729.         IO_WriteS(Tree_f, (STRING)"));", 3L);
  1730.         IO_WriteNl(Tree_f);
  1731.       }
  1732.       if (Sets_IsElement(ORD('y'), &Tree_Options)) {
  1733.         IO_WriteS(Tree_f, (STRING)" yyOldToNewStoreSize := yyInitOldToNewStoreSize;", 48L);
  1734.         IO_WriteNl(Tree_f);
  1735.         IO_WriteS(Tree_f, (STRING)" DynArray.MakeArray (yyOldToNewStorePtr, yyOldToNewStoreSize, SYSTEM.TSIZE (yytOldToNew));", 90L);
  1736.         IO_WriteNl(Tree_f);
  1737.       }
  1738.       IO_WriteS(Tree_f, (STRING)" Begin", 6L);
  1739.       Tree_WI(Tree_iModule);
  1740.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1741.       IO_WriteNl(Tree_f);
  1742.       IO_WriteS(Tree_f, (STRING)"END ", 4L);
  1743.       Tree_WI(Tree_iModule);
  1744.       IO_WriteS(Tree_f, (STRING)".", 1L);
  1745.       IO_WriteNl(Tree_f);
  1746.       return;
  1747.     }
  1748.   }
  1749. }
  1750.  
  1751. static void ProcedureBodyn
  1752. # ifdef __STDC__
  1753. (Tree_tTree t)
  1754. # else
  1755. (t)
  1756. Tree_tTree t;
  1757. # endif
  1758. {
  1759.   struct S_10 yyTempo;
  1760.  
  1761.   if (t == Tree_NoTree) {
  1762.     return;
  1763.   }
  1764.   if (t->U_1.V_1.Kind == Tree_Class) {
  1765.     {
  1766.       register Tree_yClass *W_12 = &t->U_1.V_5.Class;
  1767.  
  1768.       if ((Tree_NoCodeClass & W_12->Properties) == 0X0L) {
  1769.         IO_WriteS(Tree_f, (STRING)"PROCEDURE n", 11L);
  1770.         Tree_WI(W_12->Name);
  1771.         IO_WriteS(Tree_f, (STRING)" (): ", 5L);
  1772.         Tree_WI(Tree_itTree);
  1773.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1774.         IO_WriteNl(Tree_f);
  1775.         IO_WriteS(Tree_f, (STRING)" VAR yyByteCount    : LONGINT;", 27L);
  1776.         IO_WriteNl(Tree_f);
  1777.         IO_WriteS(Tree_f, (STRING)" VAR yyt    : ", 11L);
  1778.         Tree_WI(Tree_itTree);
  1779.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1780.         IO_WriteNl(Tree_f);
  1781.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1782.         IO_WriteNl(Tree_f);
  1783.         IO_WriteS(Tree_f, (STRING)"  yyALLOC (yyt, yyNodeSize [", 28L);
  1784.         Tree_WI(W_12->Name);
  1785.         IO_WriteS(Tree_f, (STRING)"])", 2L);
  1786.         IO_WriteNl(Tree_f);
  1787.         IO_WriteS(Tree_f, (STRING)"  yyt^.yyHead.yyMark := 0;", 26L);
  1788.         IO_WriteNl(Tree_f);
  1789.         IO_WriteS(Tree_f, (STRING)"  yyt^.Kind := ", 15L);
  1790.         Tree_WI(W_12->Name);
  1791.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1792.         IO_WriteNl(Tree_f);
  1793.         iClassName = W_12->Name;
  1794.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureBodyn);
  1795.         IO_WriteS(Tree_f, (STRING)"  RETURN yyt;", 13L);
  1796.         IO_WriteNl(Tree_f);
  1797.         IO_WriteS(Tree_f, (STRING)" END n", 6L);
  1798.         Tree_WI(W_12->Name);
  1799.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1800.         IO_WriteNl(Tree_f);
  1801.         IO_WriteNl(Tree_f);
  1802.       }
  1803.       return;
  1804.     }
  1805.   }
  1806.   if (t->U_1.V_1.Kind == Tree_Child) {
  1807.     {
  1808.       register Tree_yChild *W_13 = &t->U_1.V_9.Child;
  1809.  
  1810.       IO_WriteS(Tree_f, (STRING)"  begin", 7L);
  1811.       Tree_WI(Tree_itTree);
  1812.       IO_WriteS(Tree_f, (STRING)"(yyt^.", 6L);
  1813.       Tree_WI(iClassName);
  1814.       IO_WriteS(Tree_f, (STRING)".", 1L);
  1815.       Tree_WI(W_13->Name);
  1816.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1817.       IO_WriteNl(Tree_f);
  1818.       return;
  1819.     }
  1820.   }
  1821.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1822.     {
  1823.       register Tree_yAttribute *W_14 = &t->U_1.V_10.Attribute;
  1824.  
  1825.       if ((Tree_NoCodeAttr & W_14->Properties) == 0X0L) {
  1826.         IO_WriteS(Tree_f, (STRING)"  begin", 7L);
  1827.         Tree_WI(W_14->Type);
  1828.         IO_WriteS(Tree_f, (STRING)"(yyt^.", 6L);
  1829.         Tree_WI(iClassName);
  1830.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1831.         Tree_WI(W_14->Name);
  1832.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1833.         IO_WriteNl(Tree_f);
  1834.       }
  1835.       return;
  1836.     }
  1837.   }
  1838. }
  1839.  
  1840. static void ProcedureBodym
  1841. # ifdef __STDC__
  1842. (Tree_tTree t)
  1843. # else
  1844. (t)
  1845. Tree_tTree t;
  1846. # endif
  1847. {
  1848.   struct S_11 yyTempo;
  1849.  
  1850.   if (t == Tree_NoTree) {
  1851.     return;
  1852.   }
  1853.   if (t->U_1.V_1.Kind == Tree_Class) {
  1854.     {
  1855.       register Tree_yClass *W_15 = &t->U_1.V_5.Class;
  1856.  
  1857.       if ((Tree_NoCodeClass & W_15->Properties) == 0X0L) {
  1858.         ProcedureHeadingm(t);
  1859.         IO_WriteS(Tree_f, (STRING)" VAR yyByteCount    : LONGINT;", 27L);
  1860.         IO_WriteNl(Tree_f);
  1861.         IO_WriteS(Tree_f, (STRING)" VAR yyt    : ", 11L);
  1862.         Tree_WI(Tree_itTree);
  1863.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1864.         IO_WriteNl(Tree_f);
  1865.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  1866.         IO_WriteNl(Tree_f);
  1867.         IO_WriteS(Tree_f, (STRING)"  yyALLOC (yyt, yyNodeSize [", 28L);
  1868.         Tree_WI(W_15->Name);
  1869.         IO_WriteS(Tree_f, (STRING)"])", 2L);
  1870.         IO_WriteNl(Tree_f);
  1871.         IO_WriteS(Tree_f, (STRING)"  yyt^.yyHead.yyMark := 0;", 26L);
  1872.         IO_WriteNl(Tree_f);
  1873.         IO_WriteS(Tree_f, (STRING)"  yyt^.Kind := ", 15L);
  1874.         Tree_WI(W_15->Name);
  1875.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1876.         IO_WriteNl(Tree_f);
  1877.         if (((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_15->Properties) != 0X0L) {
  1878.           IO_WriteS(Tree_f, (STRING)"  WITH yyt^.", 12L);
  1879.           Tree_WI(W_15->Name);
  1880.           IO_WriteS(Tree_f, (STRING)" DO", 3L);
  1881.           IO_WriteNl(Tree_f);
  1882.           Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureBodym);
  1883.           IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  1884.           IO_WriteNl(Tree_f);
  1885.         }
  1886.         IO_WriteS(Tree_f, (STRING)"  RETURN yyt;", 13L);
  1887.         IO_WriteNl(Tree_f);
  1888.         IO_WriteS(Tree_f, (STRING)" END m", 6L);
  1889.         Tree_WI(W_15->Name);
  1890.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1891.         IO_WriteNl(Tree_f);
  1892.         IO_WriteNl(Tree_f);
  1893.       }
  1894.       return;
  1895.     }
  1896.   }
  1897.   if (t->U_1.V_1.Kind == Tree_Child) {
  1898.     {
  1899.       register Tree_yChild *W_16 = &t->U_1.V_9.Child;
  1900.  
  1901.       if (IN(Tree_Input, W_16->Properties)) {
  1902.         IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1903.         Tree_WI(W_16->Name);
  1904.         IO_WriteS(Tree_f, (STRING)" := p", 5L);
  1905.         Tree_WI(W_16->Name);
  1906.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1907.         IO_WriteNl(Tree_f);
  1908.       } else {
  1909.         IO_WriteS(Tree_f, (STRING)"   begin", 8L);
  1910.         Tree_WI(Tree_itTree);
  1911.         IO_WriteS(Tree_f, (STRING)"(", 1L);
  1912.         Tree_WI(W_16->Name);
  1913.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1914.         IO_WriteNl(Tree_f);
  1915.       }
  1916.       return;
  1917.     }
  1918.   }
  1919.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1920.     {
  1921.       register Tree_yAttribute *W_17 = &t->U_1.V_10.Attribute;
  1922.  
  1923.       if ((Tree_NoCodeAttr & W_17->Properties) == 0X0L) {
  1924.         if (IN(Tree_Input, W_17->Properties)) {
  1925.           IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1926.           Tree_WI(W_17->Name);
  1927.           IO_WriteS(Tree_f, (STRING)" := p", 5L);
  1928.           Tree_WI(W_17->Name);
  1929.           IO_WriteS(Tree_f, (STRING)";", 1L);
  1930.           IO_WriteNl(Tree_f);
  1931.         } else {
  1932.           IO_WriteS(Tree_f, (STRING)"   begin", 8L);
  1933.           Tree_WI(W_17->Type);
  1934.           IO_WriteS(Tree_f, (STRING)"(", 1L);
  1935.           Tree_WI(W_17->Name);
  1936.           IO_WriteS(Tree_f, (STRING)")", 1L);
  1937.           IO_WriteNl(Tree_f);
  1938.         }
  1939.       }
  1940.       return;
  1941.     }
  1942.   }
  1943. }
  1944.  
  1945. static void ReleaseAttributes1
  1946. # ifdef __STDC__
  1947. (Tree_tTree t)
  1948. # else
  1949. (t)
  1950. Tree_tTree t;
  1951. # endif
  1952. {
  1953.   struct S_12 yyTempo;
  1954.  
  1955.   if (t == Tree_NoTree) {
  1956.     return;
  1957.   }
  1958.   if (t->U_1.V_1.Kind == Tree_Class) {
  1959.     {
  1960.       register Tree_yClass *W_18 = &t->U_1.V_5.Class;
  1961.  
  1962.       if ((Tree_NoCodeClass & W_18->Properties) == 0X0L && IN(Tree_HasChildren, W_18->Properties)) {
  1963.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  1964.         Tree_WI(W_18->Name);
  1965.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1966.         IO_WriteNl(Tree_f);
  1967.         iClassName = W_18->Name;
  1968.         Tree_ForallAttributes(t, (Tree_ProcOfT)ReleaseAttributes1);
  1969.       }
  1970.       return;
  1971.     }
  1972.   }
  1973.   if (t->U_1.V_1.Kind == Tree_Child) {
  1974.     {
  1975.       register Tree_yChild *W_19 = &t->U_1.V_9.Child;
  1976.  
  1977.       IO_WriteS(Tree_f, (STRING)"close", 5L);
  1978.       Tree_WI(Tree_itTree);
  1979.       IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  1980.       Tree_WI(iClassName);
  1981.       IO_WriteS(Tree_f, (STRING)".", 1L);
  1982.       Tree_WI(W_19->Name);
  1983.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1984.       IO_WriteNl(Tree_f);
  1985.       return;
  1986.     }
  1987.   }
  1988. }
  1989.  
  1990. static void ReleaseAttributes2
  1991. # ifdef __STDC__
  1992. (Tree_tTree t)
  1993. # else
  1994. (t)
  1995. Tree_tTree t;
  1996. # endif
  1997. {
  1998.   struct S_13 yyTempo;
  1999.  
  2000.   if (t == Tree_NoTree) {
  2001.     return;
  2002.   }
  2003.   if (t->U_1.V_1.Kind == Tree_Class) {
  2004.     {
  2005.       register Tree_yClass *W_20 = &t->U_1.V_5.Class;
  2006.  
  2007.       if ((Tree_NoCodeClass & W_20->Properties) == 0X0L && IN(Tree_HasAttributes, W_20->Properties)) {
  2008.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2009.         Tree_WI(W_20->Name);
  2010.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2011.         IO_WriteNl(Tree_f);
  2012.         iClassName = W_20->Name;
  2013.         Tree_ForallAttributes(t, (Tree_ProcOfT)ReleaseAttributes2);
  2014.       }
  2015.       return;
  2016.     }
  2017.   }
  2018.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2019.     {
  2020.       register Tree_yAttribute *W_21 = &t->U_1.V_10.Attribute;
  2021.  
  2022.       if ((Tree_NoCodeAttr & W_21->Properties) == 0X0L) {
  2023.         IO_WriteS(Tree_f, (STRING)"close", 5L);
  2024.         Tree_WI(W_21->Type);
  2025.         IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  2026.         Tree_WI(iClassName);
  2027.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2028.         Tree_WI(W_21->Name);
  2029.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2030.         IO_WriteNl(Tree_f);
  2031.       }
  2032.       return;
  2033.     }
  2034.   }
  2035. }
  2036.  
  2037. static void TraverseTD
  2038. # ifdef __STDC__
  2039. (Tree_tTree t)
  2040. # else
  2041. (t)
  2042. Tree_tTree t;
  2043. # endif
  2044. {
  2045.   struct S_14 yyTempo;
  2046.  
  2047.   if (t == Tree_NoTree) {
  2048.     return;
  2049.   }
  2050.   if (t->U_1.V_1.Kind == Tree_Class) {
  2051.     {
  2052.       register Tree_yClass *W_22 = &t->U_1.V_5.Class;
  2053.  
  2054.       if ((Tree_NoCodeClass & W_22->Properties) == 0X0L && IN(Tree_HasChildren, W_22->Properties)) {
  2055.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2056.         Tree_WI(W_22->Name);
  2057.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2058.         IO_WriteNl(Tree_f);
  2059.         TreeMod2_GetIterator(t);
  2060.         iClassName = W_22->Name;
  2061.         Tree_ForallAttributes(t, (Tree_ProcOfT)TraverseTD);
  2062.         if (TreeMod2_Iterator == Tree_NoTree) {
  2063.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  2064.           IO_WriteNl(Tree_f);
  2065.         } else {
  2066.           IO_WriteS(Tree_f, (STRING)"yyt := yyt^.", 12L);
  2067.           Tree_WI(iClassName);
  2068.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2069.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  2070.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2071.           IO_WriteNl(Tree_f);
  2072.         }
  2073.       }
  2074.       return;
  2075.     }
  2076.   }
  2077.   if (t->U_1.V_1.Kind == Tree_Child) {
  2078.     {
  2079.       register Tree_yChild *W_23 = &t->U_1.V_9.Child;
  2080.  
  2081.       if (t != TreeMod2_Iterator) {
  2082.         IO_WriteS(Tree_f, (STRING)"yyTraverse", 10L);
  2083.         Tree_WI(Tree_iModule);
  2084.         IO_WriteS(Tree_f, (STRING)"TD (yyt^.", 9L);
  2085.         Tree_WI(iClassName);
  2086.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2087.         Tree_WI(W_23->Name);
  2088.         IO_WriteS(Tree_f, (STRING)");", 2L);
  2089.         IO_WriteNl(Tree_f);
  2090.       }
  2091.       return;
  2092.     }
  2093.   }
  2094. }
  2095.  
  2096. static void TraverseBU
  2097. # ifdef __STDC__
  2098. (Tree_tTree t)
  2099. # else
  2100. (t)
  2101. Tree_tTree t;
  2102. # endif
  2103. {
  2104.   struct S_15 yyTempo;
  2105.  
  2106.   if (t == Tree_NoTree) {
  2107.     return;
  2108.   }
  2109.   if (t->U_1.V_1.Kind == Tree_Class) {
  2110.     {
  2111.       register Tree_yClass *W_24 = &t->U_1.V_5.Class;
  2112.  
  2113.       if ((Tree_NoCodeClass & W_24->Properties) == 0X0L && IN(Tree_HasChildren, W_24->Properties)) {
  2114.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2115.         Tree_WI(W_24->Name);
  2116.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2117.         IO_WriteNl(Tree_f);
  2118.         TreeMod2_GetIterator(t);
  2119.         iClassName = W_24->Name;
  2120.         Tree_ForallAttributes(t, (Tree_ProcOfT)TraverseBU);
  2121.         if (TreeMod2_Iterator == Tree_NoTree) {
  2122.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  2123.           IO_WriteNl(Tree_f);
  2124.         } else {
  2125.           IO_WriteS(Tree_f, (STRING)"yyTraverse", 10L);
  2126.           Tree_WI(Tree_iModule);
  2127.           IO_WriteS(Tree_f, (STRING)"BU (yyt^.", 9L);
  2128.           Tree_WI(iClassName);
  2129.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2130.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  2131.           IO_WriteS(Tree_f, (STRING)");", 2L);
  2132.           IO_WriteNl(Tree_f);
  2133.         }
  2134.       }
  2135.       return;
  2136.     }
  2137.   }
  2138.   if (t->U_1.V_1.Kind == Tree_Child) {
  2139.     {
  2140.       register Tree_yChild *W_25 = &t->U_1.V_9.Child;
  2141.  
  2142.       if (t != TreeMod2_Iterator) {
  2143.         IO_WriteS(Tree_f, (STRING)"yyTraverse", 10L);
  2144.         Tree_WI(Tree_iModule);
  2145.         IO_WriteS(Tree_f, (STRING)"BU (yyt^.", 9L);
  2146.         Tree_WI(iClassName);
  2147.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2148.         Tree_WI(W_25->Name);
  2149.         IO_WriteS(Tree_f, (STRING)");", 2L);
  2150.         IO_WriteNl(Tree_f);
  2151.       }
  2152.       return;
  2153.     }
  2154.   }
  2155. }
  2156.  
  2157. static void Reverse1
  2158. # ifdef __STDC__
  2159. (Tree_tTree t)
  2160. # else
  2161. (t)
  2162. Tree_tTree t;
  2163. # endif
  2164. {
  2165.   struct S_16 yyTempo;
  2166.  
  2167.   if (t == Tree_NoTree) {
  2168.     return;
  2169.   }
  2170.   if (t->U_1.V_1.Kind == Tree_Class) {
  2171.     {
  2172.       register Tree_yClass *W_26 = &t->U_1.V_5.Class;
  2173.  
  2174.       if ((Tree_NoCodeClass & W_26->Properties) == 0X0L) {
  2175.         iClassName = W_26->Name;
  2176.         Tree_ForallAttributes(t, (Tree_ProcOfT)Reverse1);
  2177.       }
  2178.       return;
  2179.     }
  2180.   }
  2181.   if (t->U_1.V_1.Kind == Tree_Child) {
  2182.     {
  2183.       register Tree_yChild *W_27 = &t->U_1.V_9.Child;
  2184.  
  2185.       if (IN(Tree_Reverse, W_27->Properties)) {
  2186.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2187.         Tree_WI(iClassName);
  2188.         IO_WriteS(Tree_f, (STRING)": yyNext := yyOld^.", 19L);
  2189.         Tree_WI(iClassName);
  2190.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2191.         Tree_WI(W_27->Name);
  2192.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2193.         IO_WriteS(Tree_f, (STRING)" yyOld^.", 8L);
  2194.         Tree_WI(iClassName);
  2195.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2196.         Tree_WI(W_27->Name);
  2197.         IO_WriteS(Tree_f, (STRING)" := yyNew;", 10L);
  2198.         IO_WriteNl(Tree_f);
  2199.       }
  2200.       return;
  2201.     }
  2202.   }
  2203. }
  2204.  
  2205. static void Reverse2
  2206. # ifdef __STDC__
  2207. (Tree_tTree t)
  2208. # else
  2209. (t)
  2210. Tree_tTree t;
  2211. # endif
  2212. {
  2213.   struct S_17 yyTempo;
  2214.  
  2215.   if (t == Tree_NoTree) {
  2216.     return;
  2217.   }
  2218.   if (t->U_1.V_1.Kind == Tree_Class) {
  2219.     {
  2220.       register Tree_yClass *W_28 = &t->U_1.V_5.Class;
  2221.  
  2222.       if ((Tree_NoCodeClass & W_28->Properties) == 0X0L) {
  2223.         iClassName = W_28->Name;
  2224.         Tree_ForallAttributes(t, (Tree_ProcOfT)Reverse2);
  2225.       }
  2226.       return;
  2227.     }
  2228.   }
  2229.   if (t->U_1.V_1.Kind == Tree_Child) {
  2230.     {
  2231.       register Tree_yChild *W_29 = &t->U_1.V_9.Child;
  2232.  
  2233.       if (IN(Tree_Reverse, W_29->Properties)) {
  2234.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2235.         Tree_WI(iClassName);
  2236.         IO_WriteS(Tree_f, (STRING)": yyTail^.", 10L);
  2237.         Tree_WI(iClassName);
  2238.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2239.         Tree_WI(W_29->Name);
  2240.         IO_WriteS(Tree_f, (STRING)" := yyOld;", 10L);
  2241.         IO_WriteNl(Tree_f);
  2242.       }
  2243.       return;
  2244.     }
  2245.   }
  2246. }
  2247.  
  2248. static void Copy
  2249. # ifdef __STDC__
  2250. (Tree_tTree t)
  2251. # else
  2252. (t)
  2253. Tree_tTree t;
  2254. # endif
  2255. {
  2256.   struct S_18 yyTempo;
  2257.  
  2258.   if (t == Tree_NoTree) {
  2259.     return;
  2260.   }
  2261.   if (t->U_1.V_1.Kind == Tree_Class) {
  2262.     {
  2263.       register Tree_yClass *W_30 = &t->U_1.V_5.Class;
  2264.  
  2265.       if ((Tree_NoCodeClass & W_30->Properties) == 0X0L) {
  2266.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2267.         Tree_WI(W_30->Name);
  2268.         IO_WriteS(Tree_f, (STRING)": yyNew^^.", 10L);
  2269.         Tree_WI(W_30->Name);
  2270.         IO_WriteS(Tree_f, (STRING)" := yyt^.", 9L);
  2271.         Tree_WI(W_30->Name);
  2272.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2273.         IO_WriteNl(Tree_f);
  2274.         TreeMod2_GetIterator(t);
  2275.         iClassName = W_30->Name;
  2276.         Tree_ForallAttributes(t, (Tree_ProcOfT)Copy);
  2277.         if (TreeMod2_Iterator == Tree_NoTree) {
  2278.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  2279.           IO_WriteNl(Tree_f);
  2280.         } else {
  2281.           IO_WriteS(Tree_f, (STRING)"yyt := yyt^.", 12L);
  2282.           Tree_WI(W_30->Name);
  2283.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2284.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  2285.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2286.           IO_WriteNl(Tree_f);
  2287.           IO_WriteS(Tree_f, (STRING)"yyNew := SYSTEM.ADR (yyNew^^.", 29L);
  2288.           Tree_WI(W_30->Name);
  2289.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2290.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  2291.           IO_WriteS(Tree_f, (STRING)");", 2L);
  2292.           IO_WriteNl(Tree_f);
  2293.         }
  2294.       }
  2295.       return;
  2296.     }
  2297.   }
  2298.   if (t->U_1.V_1.Kind == Tree_Child) {
  2299.     {
  2300.       register Tree_yChild *W_31 = &t->U_1.V_9.Child;
  2301.  
  2302.       if (t != TreeMod2_Iterator) {
  2303.         IO_WriteS(Tree_f, (STRING)"copy", 4L);
  2304.         Tree_WI(Tree_itTree);
  2305.         IO_WriteS(Tree_f, (STRING)" (yyNew^^.", 10L);
  2306.         Tree_WI(iClassName);
  2307.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2308.         Tree_WI(W_31->Name);
  2309.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2310.         IO_WriteS(Tree_f, (STRING)"yyt^.", 5L);
  2311.         Tree_WI(iClassName);
  2312.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2313.         Tree_WI(W_31->Name);
  2314.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2315.         IO_WriteNl(Tree_f);
  2316.       }
  2317.       return;
  2318.     }
  2319.   }
  2320.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2321.     {
  2322.       register Tree_yAttribute *W_32 = &t->U_1.V_10.Attribute;
  2323.  
  2324.       if ((Tree_NoCodeAttr & W_32->Properties) == 0X0L) {
  2325.         IO_WriteS(Tree_f, (STRING)"copy", 4L);
  2326.         Tree_WI(W_32->Type);
  2327.         IO_WriteS(Tree_f, (STRING)" (yyNew^^.", 10L);
  2328.         Tree_WI(iClassName);
  2329.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2330.         Tree_WI(W_32->Name);
  2331.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2332.         IO_WriteS(Tree_f, (STRING)"yyt^.", 5L);
  2333.         Tree_WI(iClassName);
  2334.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2335.         Tree_WI(W_32->Name);
  2336.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2337.         IO_WriteNl(Tree_f);
  2338.       }
  2339.       return;
  2340.     }
  2341.   }
  2342. }
  2343.  
  2344. static void CheckAttributes
  2345. # ifdef __STDC__
  2346. (Tree_tTree t)
  2347. # else
  2348. (t)
  2349. Tree_tTree t;
  2350. # endif
  2351. {
  2352.   struct S_19 yyTempo;
  2353.  
  2354.   if (t == Tree_NoTree) {
  2355.     return;
  2356.   }
  2357.   if (t->U_1.V_1.Kind == Tree_Class) {
  2358.     {
  2359.       register Tree_yClass *W_33 = &t->U_1.V_5.Class;
  2360.  
  2361.       if ((Tree_NoCodeClass & W_33->Properties) == 0X0L && IN(Tree_HasChildren, W_33->Properties)) {
  2362.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2363.         Tree_WI(W_33->Name);
  2364.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2365.         IO_WriteNl(Tree_f);
  2366.         iClassName = W_33->Name;
  2367.         Tree_ForallAttributes(t, (Tree_ProcOfT)CheckAttributes);
  2368.       }
  2369.       return;
  2370.     }
  2371.   }
  2372.   if (t->U_1.V_1.Kind == Tree_Child) {
  2373.     {
  2374.       register Tree_yChild *W_34 = &t->U_1.V_9.Child;
  2375.  
  2376.       IO_WriteS(Tree_f, (STRING)"yyResult := yyCheckChild (yyt, yyt^.", 36L);
  2377.       Tree_WI(iClassName);
  2378.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2379.       Tree_WI(W_34->Name);
  2380.       IO_WriteS(Tree_f, (STRING)", ", 2L);
  2381.       Tree_WI(W_34->Type);
  2382.       IO_WriteS(Tree_f, (STRING)", '", 3L);
  2383.       Tree_WI(W_34->Name);
  2384.       IO_WriteS(Tree_f, (STRING)"') AND yyResult;", 16L);
  2385.       IO_WriteNl(Tree_f);
  2386.       return;
  2387.     }
  2388.   }
  2389. }
  2390.  
  2391. static void InitTypeRange
  2392. # ifdef __STDC__
  2393. (Tree_tTree t)
  2394. # else
  2395. (t)
  2396. Tree_tTree t;
  2397. # endif
  2398. {
  2399.   struct S_20 yyTempo;
  2400.  
  2401.   if (t == Tree_NoTree) {
  2402.     return;
  2403.   }
  2404.   if (t->U_1.V_1.Kind == Tree_Class) {
  2405.     {
  2406.       register Tree_yClass *W_35 = &t->U_1.V_5.Class;
  2407.  
  2408.       if ((Tree_NoCodeClass & W_35->Properties) == 0X0L) {
  2409.         iRange = W_35->Name;
  2410.         Tree_ForallClasses(W_35->Extensions, (Tree_ProcOfT)InitTypeRange2);
  2411.         IO_WriteS(Tree_f, (STRING)" yyTypeRange [", 14L);
  2412.         Tree_WI(W_35->Name);
  2413.         IO_WriteS(Tree_f, (STRING)"] := ", 5L);
  2414.         Tree_WI(iRange);
  2415.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2416.         IO_WriteNl(Tree_f);
  2417.       }
  2418.       return;
  2419.     }
  2420.   }
  2421. }
  2422.  
  2423. static void InitTypeRange2
  2424. # ifdef __STDC__
  2425. (Tree_tTree t)
  2426. # else
  2427. (t)
  2428. Tree_tTree t;
  2429. # endif
  2430. {
  2431.   struct S_21 yyTempo;
  2432.  
  2433.   if (t == Tree_NoTree) {
  2434.     return;
  2435.   }
  2436.   if (t->U_1.V_1.Kind == Tree_Class) {
  2437.     {
  2438.       register Tree_yClass *W_36 = &t->U_1.V_5.Class;
  2439.  
  2440.       iRange = W_36->Name;
  2441.       return;
  2442.     }
  2443.   }
  2444. }
  2445.  
  2446. static void QueryAttributes
  2447. # ifdef __STDC__
  2448. (Tree_tTree t)
  2449. # else
  2450. (t)
  2451. Tree_tTree t;
  2452. # endif
  2453. {
  2454.   struct S_22 yyTempo;
  2455.  
  2456.   if (t == Tree_NoTree) {
  2457.     return;
  2458.   }
  2459.   if (t->U_1.V_1.Kind == Tree_Class) {
  2460.     {
  2461.       register Tree_yClass *W_37 = &t->U_1.V_5.Class;
  2462.  
  2463.       if ((Tree_NoCodeClass & W_37->Properties) == 0X0L && IN(Tree_HasChildren, W_37->Properties)) {
  2464.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2465.         Tree_WI(W_37->Name);
  2466.         IO_WriteS(Tree_f, (STRING)": IF FALSE THEN", 15L);
  2467.         IO_WriteNl(Tree_f);
  2468.         iClassName = W_37->Name;
  2469.         Tree_ForallAttributes(t, (Tree_ProcOfT)QueryAttributes);
  2470.         IO_WriteS(Tree_f, (STRING)"END;", 4L);
  2471.         IO_WriteNl(Tree_f);
  2472.       }
  2473.       return;
  2474.     }
  2475.   }
  2476.   if (t->U_1.V_1.Kind == Tree_Child) {
  2477.     {
  2478.       register Tree_yChild *W_38 = &t->U_1.V_9.Child;
  2479.  
  2480.       IO_WriteS(Tree_f, (STRING)"ELSIF yyyIsEqual ('", 19L);
  2481.       Tree_WI(W_38->Name);
  2482.       IO_WriteS(Tree_f, (STRING)"') THEN Query", 13L);
  2483.       Tree_WI(Tree_iModule);
  2484.       IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  2485.       Tree_WI(iClassName);
  2486.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2487.       Tree_WI(W_38->Name);
  2488.       IO_WriteS(Tree_f, (STRING)");", 2L);
  2489.       IO_WriteNl(Tree_f);
  2490.       return;
  2491.     }
  2492.   }
  2493. }
  2494.  
  2495. static void IsEqualAttributes
  2496. # ifdef __STDC__
  2497. (Tree_tTree t)
  2498. # else
  2499. (t)
  2500. Tree_tTree t;
  2501. # endif
  2502. {
  2503.   struct S_23 yyTempo;
  2504.  
  2505.   if (t == Tree_NoTree) {
  2506.     return;
  2507.   }
  2508.   if (t->U_1.V_1.Kind == Tree_Class) {
  2509.     {
  2510.       register Tree_yClass *W_39 = &t->U_1.V_5.Class;
  2511.  
  2512.       if ((Tree_NoCodeClass & W_39->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_39->Properties) != 0X0L) {
  2513.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2514.         Tree_WI(W_39->Name);
  2515.         IO_WriteS(Tree_f, (STRING)": RETURN TRUE", 13L);
  2516.         IO_WriteNl(Tree_f);
  2517.         iClassName = W_39->Name;
  2518.         Tree_ForallAttributes(t, (Tree_ProcOfT)IsEqualAttributes);
  2519.       }
  2520.       return;
  2521.     }
  2522.   }
  2523.   if (t->U_1.V_1.Kind == Tree_Child) {
  2524.     {
  2525.       register Tree_yChild *W_40 = &t->U_1.V_9.Child;
  2526.  
  2527.       IO_WriteS(Tree_f, (STRING)"AND equal", 9L);
  2528.       Tree_WI(Tree_itTree);
  2529.       IO_WriteS(Tree_f, (STRING)" (yyt1^.", 8L);
  2530.       Tree_WI(iClassName);
  2531.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2532.       Tree_WI(W_40->Name);
  2533.       IO_WriteS(Tree_f, (STRING)", yyt2^.", 8L);
  2534.       Tree_WI(iClassName);
  2535.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2536.       Tree_WI(W_40->Name);
  2537.       IO_WriteS(Tree_f, (STRING)")", 1L);
  2538.       IO_WriteNl(Tree_f);
  2539.       return;
  2540.     }
  2541.   }
  2542.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2543.     {
  2544.       register Tree_yAttribute *W_41 = &t->U_1.V_10.Attribute;
  2545.  
  2546.       if ((Tree_NoCodeAttr & W_41->Properties) == 0X0L) {
  2547.         IO_WriteS(Tree_f, (STRING)"AND (equal", 10L);
  2548.         Tree_WI(W_41->Type);
  2549.         IO_WriteS(Tree_f, (STRING)" (yyt1^.", 8L);
  2550.         Tree_WI(iClassName);
  2551.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2552.         Tree_WI(W_41->Name);
  2553.         IO_WriteS(Tree_f, (STRING)", yyt2^.", 8L);
  2554.         Tree_WI(iClassName);
  2555.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2556.         Tree_WI(W_41->Name);
  2557.         IO_WriteS(Tree_f, (STRING)"))", 2L);
  2558.         IO_WriteNl(Tree_f);
  2559.       }
  2560.       return;
  2561.     }
  2562.   }
  2563. }
  2564.  
  2565. static void InitAttributes
  2566. # ifdef __STDC__
  2567. (Tree_tTree t)
  2568. # else
  2569. (t)
  2570. Tree_tTree t;
  2571. # endif
  2572. {
  2573.   struct S_24 yyTempo;
  2574.  
  2575.   if (t == Tree_NoTree) {
  2576.     return;
  2577.   }
  2578.   if (t->U_1.V_1.Kind == Tree_Class) {
  2579.     for (;;) {
  2580.       {
  2581.         register Tree_yClass *W_42 = &t->U_1.V_5.Class;
  2582.  
  2583.         if (!((Tree_NoCodeClass & W_42->Properties) == 0X0L && IN(Tree_HasChildren, W_42->Properties))) {
  2584.           goto EXIT_1;
  2585.         }
  2586.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  2587.         Tree_WI(W_42->Name);
  2588.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2589.         IO_WriteNl(Tree_f);
  2590.         TreeMod2_GetIterator(t);
  2591.         iClassName = W_42->Name;
  2592.         gBitCount = W_42->BitCount;
  2593.         Tree_ForallAttributes(t, (Tree_ProcOfT)InitAttributes);
  2594.         if (TreeMod2_Iterator == Tree_NoTree || !IN(Tree_Input, TreeMod2_Iterator->U_1.V_9.Child.Properties)) {
  2595.           IO_WriteS(Tree_f, (STRING)"RETURN;", 7L);
  2596.           IO_WriteNl(Tree_f);
  2597.         } else {
  2598.           IO_WriteS(Tree_f, (STRING)"yyt := yyt^.", 12L);
  2599.           Tree_WI(iClassName);
  2600.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2601.           Tree_WI(TreeMod2_Iterator->U_1.V_9.Child.Name);
  2602.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2603.           IO_WriteNl(Tree_f);
  2604.         }
  2605.         return;
  2606.       }
  2607.     } EXIT_1:;
  2608.   }
  2609.   if (t->U_1.V_1.Kind == Tree_Child) {
  2610.     for (;;) {
  2611.       {
  2612.         register Tree_yChild *W_43 = &t->U_1.V_9.Child;
  2613.  
  2614.         if (!IN(Tree_Input, W_43->Properties)) {
  2615.           goto EXIT_2;
  2616.         }
  2617.         IO_WriteS(Tree_f, (STRING)"WITH yyt^.", 10L);
  2618.         Tree_WI(iClassName);
  2619.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2620.         Tree_WI(W_43->Name);
  2621.         IO_WriteS(Tree_f, (STRING)"^.yyHead DO yyOffset := ", 24L);
  2622.         Tree_WN((LONGINT)(gBitCount + W_43->BitOffset));
  2623.         IO_WriteS(Tree_f, (STRING)"; yyParent := yyt; END;", 23L);
  2624.         IO_WriteNl(Tree_f);
  2625.         if (!(t != TreeMod2_Iterator)) {
  2626.           goto EXIT_2;
  2627.         }
  2628.         IO_WriteS(Tree_f, (STRING)"Init", 4L);
  2629.         Tree_WI(Tree_iModule);
  2630.         IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  2631.         Tree_WI(iClassName);
  2632.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2633.         Tree_WI(W_43->Name);
  2634.         IO_WriteS(Tree_f, (STRING)");", 2L);
  2635.         IO_WriteNl(Tree_f);
  2636.         return;
  2637.       }
  2638.     } EXIT_2:;
  2639.   }
  2640. }
  2641.  
  2642. static void InitNodeSize
  2643. # ifdef __STDC__
  2644. (Tree_tTree t)
  2645. # else
  2646. (t)
  2647. Tree_tTree t;
  2648. # endif
  2649. {
  2650.   struct S_25 yyTempo;
  2651.  
  2652.   if (t == Tree_NoTree) {
  2653.     return;
  2654.   }
  2655.   if (t->U_1.V_1.Kind == Tree_Class) {
  2656.     for (;;) {
  2657.       {
  2658.         register Tree_yClass *W_44 = &t->U_1.V_5.Class;
  2659.  
  2660.         if (!((Tree_NoCodeClass & W_44->Properties) == 0X0L)) {
  2661.           goto EXIT_3;
  2662.         }
  2663.         IO_WriteS(Tree_f, (STRING)" yyNodeSize [", 13L);
  2664.         Tree_WI(W_44->Name);
  2665.         IO_WriteS(Tree_f, (STRING)"] := SYSTEM.TSIZE (y", 20L);
  2666.         Tree_WI(W_44->Name);
  2667.         IO_WriteS(Tree_f, (STRING)");", 2L);
  2668.         IO_WriteNl(Tree_f);
  2669.         return;
  2670.       }
  2671.     } EXIT_3:;
  2672.   }
  2673. }
  2674.  
  2675. void TreeMod1_ImportList
  2676. # ifdef __STDC__
  2677. (Tree_tTree t)
  2678. # else
  2679. (t)
  2680. Tree_tTree t;
  2681. # endif
  2682. {
  2683.   struct S_26 yyTempo;
  2684.  
  2685.   if (t == Tree_NoTree) {
  2686.     return;
  2687.   }
  2688.   if (t->U_1.V_1.Kind == Tree_Ag) {
  2689.     {
  2690.       register Tree_yAg *W_45 = &t->U_1.V_26.Ag;
  2691.  
  2692.       IO_WriteS(Tree_f, (STRING)"FROM ", 5L);
  2693.       Tree_WI(Tree_iMain);
  2694.       IO_WriteS(Tree_f, (STRING)" IMPORT", 7L);
  2695.       IO_WriteNl(Tree_f);
  2696.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  2697.         Tree_WI(Tree_iNoTree);
  2698.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2699.         Tree_WI(Tree_itTree);
  2700.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2701.         Tree_WI(Tree_iMain);
  2702.         IO_WriteS(Tree_f, (STRING)"Root, Make", 10L);
  2703.         Tree_WI(Tree_iMain);
  2704.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2705.         IO_WriteNl(Tree_f);
  2706.       }
  2707.       Tree_ForallClasses(W_45->Classes, (Tree_ProcOfT)TreeMod1_ImportList);
  2708.       if (Sets_IsElement(ORD('f'), &Tree_Options)) {
  2709.         IO_WriteS(Tree_f, (STRING)"Release", 7L);
  2710.         Tree_WI(Tree_iModule);
  2711.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2712.         IO_WriteNl(Tree_f);
  2713.       }
  2714.       if (Sets_IsElement(ORD('F'), &Tree_Options) && !Sets_IsElement(ORD('<'), &Tree_Options)) {
  2715.         IO_WriteS(Tree_f, (STRING)"Release", 7L);
  2716.         Tree_WI(Tree_iModule);
  2717.         IO_WriteS(Tree_f, (STRING)"Module,", 7L);
  2718.         IO_WriteNl(Tree_f);
  2719.       }
  2720.       if (Sets_IsElement(ORD('o'), &Tree_Options)) {
  2721.         IO_WriteS(Tree_f, (STRING)"Write", 5L);
  2722.         Tree_WI(Tree_iModule);
  2723.         IO_WriteS(Tree_f, (STRING)"Node,", 5L);
  2724.         IO_WriteNl(Tree_f);
  2725.       }
  2726.       if (Sets_IsElement(ORD('w'), &Tree_Options)) {
  2727.         IO_WriteS(Tree_f, (STRING)"Write", 5L);
  2728.         Tree_WI(Tree_iModule);
  2729.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2730.         IO_WriteNl(Tree_f);
  2731.       }
  2732.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  2733.         IO_WriteS(Tree_f, (STRING)"Read", 4L);
  2734.         Tree_WI(Tree_iModule);
  2735.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2736.         IO_WriteNl(Tree_f);
  2737.       }
  2738.       if (Sets_IsElement(ORD('p'), &Tree_Options)) {
  2739.         IO_WriteS(Tree_f, (STRING)"Put", 3L);
  2740.         Tree_WI(Tree_iModule);
  2741.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2742.         IO_WriteNl(Tree_f);
  2743.       }
  2744.       if (Sets_IsElement(ORD('g'), &Tree_Options)) {
  2745.         IO_WriteS(Tree_f, (STRING)"Get", 3L);
  2746.         Tree_WI(Tree_iModule);
  2747.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2748.         IO_WriteNl(Tree_f);
  2749.       }
  2750.       if (Sets_IsElement(ORD('t'), &Tree_Options)) {
  2751.         IO_WriteS(Tree_f, (STRING)"Traverse", 8L);
  2752.         Tree_WI(Tree_iModule);
  2753.         IO_WriteS(Tree_f, (STRING)"TD,", 3L);
  2754.         IO_WriteNl(Tree_f);
  2755.       }
  2756.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  2757.         IO_WriteS(Tree_f, (STRING)"Traverse", 8L);
  2758.         Tree_WI(Tree_iModule);
  2759.         IO_WriteS(Tree_f, (STRING)"BU,", 3L);
  2760.         IO_WriteNl(Tree_f);
  2761.       }
  2762.       if (Sets_IsElement(ORD('R'), &Tree_Options)) {
  2763.         IO_WriteS(Tree_f, (STRING)"Reverse", 7L);
  2764.         Tree_WI(Tree_iModule);
  2765.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2766.         IO_WriteNl(Tree_f);
  2767.       }
  2768.       if (Sets_IsElement(ORD('y'), &Tree_Options)) {
  2769.         IO_WriteS(Tree_f, (STRING)"Copy", 4L);
  2770.         Tree_WI(Tree_iModule);
  2771.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2772.         IO_WriteNl(Tree_f);
  2773.       }
  2774.       if (Sets_IsElement(ORD('k'), &Tree_Options)) {
  2775.         IO_WriteS(Tree_f, (STRING)"Check", 5L);
  2776.         Tree_WI(Tree_iModule);
  2777.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2778.         IO_WriteNl(Tree_f);
  2779.       }
  2780.       if (Sets_IsElement(ORD('q'), &Tree_Options)) {
  2781.         IO_WriteS(Tree_f, (STRING)"Query", 5L);
  2782.         Tree_WI(Tree_iModule);
  2783.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2784.         IO_WriteNl(Tree_f);
  2785.       }
  2786.       if (Sets_IsElement(ORD('='), &Tree_Options)) {
  2787.         IO_WriteS(Tree_f, (STRING)"IsEqual", 7L);
  2788.         Tree_WI(Tree_iModule);
  2789.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2790.         IO_WriteNl(Tree_f);
  2791.       }
  2792.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  2793.         IO_WriteS(Tree_f, (STRING)"Init", 4L);
  2794.         Tree_WI(Tree_iModule);
  2795.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2796.         IO_WriteNl(Tree_f);
  2797.       }
  2798.       IO_WriteS(Tree_f, (STRING)"Begin", 5L);
  2799.       Tree_WI(Tree_iModule);
  2800.       IO_WriteS(Tree_f, (STRING)",", 1L);
  2801.       IO_WriteNl(Tree_f);
  2802.       IO_WriteS(Tree_f, (STRING)"Close", 5L);
  2803.       Tree_WI(Tree_iModule);
  2804.       IO_WriteS(Tree_f, (STRING)";", 1L);
  2805.       IO_WriteNl(Tree_f);
  2806.       return;
  2807.     }
  2808.   }
  2809.   if (t->U_1.V_1.Kind == Tree_Class) {
  2810.     {
  2811.       register Tree_yClass *W_46 = &t->U_1.V_5.Class;
  2812.  
  2813.       if ((Tree_NoCodeClass & W_46->Properties) == 0X0L) {
  2814.         Tree_WI(W_46->Name);
  2815.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2816.         if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  2817.           IO_WriteS(Tree_f, (STRING)"n", 1L);
  2818.           Tree_WI(W_46->Name);
  2819.           IO_WriteS(Tree_f, (STRING)", ", 2L);
  2820.         }
  2821.         if (Sets_IsElement(ORD('m'), &Tree_Options)) {
  2822.           IO_WriteS(Tree_f, (STRING)"m", 1L);
  2823.           Tree_WI(W_46->Name);
  2824.           IO_WriteS(Tree_f, (STRING)",", 1L);
  2825.           IO_WriteNl(Tree_f);
  2826.         }
  2827.       }
  2828.       return;
  2829.     }
  2830.   }
  2831. }
  2832.  
  2833. static void ImportConst
  2834. # ifdef __STDC__
  2835. (Tree_tTree t)
  2836. # else
  2837. (t)
  2838. Tree_tTree t;
  2839. # endif
  2840. {
  2841.   struct S_27 yyTempo;
  2842.  
  2843.   if (t == Tree_NoTree) {
  2844.     return;
  2845.   }
  2846.   if (t->U_1.V_1.Kind == Tree_Class) {
  2847.     {
  2848.       register Tree_yClass *W_47 = &t->U_1.V_5.Class;
  2849.  
  2850.       if ((Tree_NoCodeClass & W_47->Properties) == 0X0L) {
  2851.         Tree_WI(W_47->Name);
  2852.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2853.         IO_WriteNl(Tree_f);
  2854.       }
  2855.       return;
  2856.     }
  2857.   }
  2858. }
  2859.  
  2860. static void CompMaxBit
  2861. # ifdef __STDC__
  2862. (Tree_tTree t)
  2863. # else
  2864. (t)
  2865. Tree_tTree t;
  2866. # endif
  2867. {
  2868.   struct S_28 yyTempo;
  2869.  
  2870.   if (t == Tree_NoTree) {
  2871.     return;
  2872.   }
  2873.   if (t->U_1.V_1.Kind == Tree_Class) {
  2874.     {
  2875.       register Tree_yClass *W_48 = &t->U_1.V_5.Class;
  2876.  
  2877.       i = 1;
  2878.       Tree_ForallAttributes(t, (Tree_ProcOfT)CompMaxBit);
  2879.       MaxBit = General_Max((LONGINT)i, (LONGINT)MaxBit);
  2880.       return;
  2881.     }
  2882.   }
  2883.   if (t->U_1.V_1.Kind == Tree_Child) {
  2884.     for (;;) {
  2885.       {
  2886.         register Tree_yChild *W_49 = &t->U_1.V_9.Child;
  2887.  
  2888.         if (!(((SET_ELEM(Tree_Input) | SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy)) & W_49->Properties) == 0X0L)) {
  2889.           goto EXIT_4;
  2890.         }
  2891.         INC(i);
  2892.         return;
  2893.       }
  2894.     } EXIT_4:;
  2895.   }
  2896.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2897.     for (;;) {
  2898.       {
  2899.         register Tree_yAttribute *W_50 = &t->U_1.V_10.Attribute;
  2900.  
  2901.         if (!(((SET_ELEM(Tree_Input) | SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy)) & W_50->Properties) == 0X0L)) {
  2902.           goto EXIT_5;
  2903.         }
  2904.         INC(i);
  2905.         return;
  2906.       }
  2907.     } EXIT_5:;
  2908.   }
  2909. }
  2910.  
  2911. void TreeMod1_BeginTreeMod1
  2912. # ifdef __STDC__
  2913. ()
  2914. # else
  2915. ()
  2916. # endif
  2917. {
  2918.   ConstCount = 0;
  2919. }
  2920.  
  2921. void TreeMod1_CloseTreeMod1
  2922. # ifdef __STDC__
  2923. ()
  2924. # else
  2925. ()
  2926. # endif
  2927. {
  2928. }
  2929.  
  2930. static void yyExit
  2931. # ifdef __STDC__
  2932. ()
  2933. # else
  2934. ()
  2935. # endif
  2936. {
  2937.   IO_CloseIO();
  2938.   Exit(1L);
  2939. }
  2940.  
  2941. void BEGIN_TreeMod1()
  2942. {
  2943.   static BOOLEAN has_been_called = FALSE;
  2944.  
  2945.   if (!has_been_called) {
  2946.     has_been_called = TRUE;
  2947.  
  2948.     BEGIN_IO();
  2949.     BEGIN_Tree();
  2950.     BEGIN_System();
  2951.     BEGIN_IO();
  2952.     BEGIN_Tree();
  2953.     BEGIN_General();
  2954.     BEGIN_IO();
  2955.     BEGIN_Idents();
  2956.     BEGIN_Texts();
  2957.     BEGIN_Sets();
  2958.     BEGIN_TreeMod2();
  2959.     BEGIN_Tree();
  2960.     BEGIN_Strings();
  2961.  
  2962.     TreeMod1_yyf = IO_StdOutput;
  2963.     TreeMod1_Exit = yyExit;
  2964.     TreeMod1_BeginTreeMod1();
  2965.   }
  2966. }
  2967.